csh/playbook

Fork 0

Files

T

ci[bot] c824ba9d7b 📦 deps(thirdparty): update snapshots

2026-07-01 16:02:41 +00:00

8.3 KiB

Raw Blame History

Inspection and Monitoring

INFO Command
Continuous Stats Mode
MONITOR Command
Latency Analysis
RDB Backup
Replica Mode
LRU Simulation
Slow Log

INFO Command

Returns server information and statistics as key-value pairs organized in sections.

# All default sections
redis-cli INFO

# Specific sections
redis-cli INFO server
redis-cli INFO memory
redis-cli INFO keyspace
redis-cli INFO replication
redis-cli INFO clients
redis-cli INFO stats
redis-cli INFO persistence
redis-cli INFO cpu
redis-cli INFO commandstats
redis-cli INFO latencystats
redis-cli INFO cluster
redis-cli INFO modules

# Multiple sections (Redis 7.0+)
redis-cli INFO memory keyspace

# All sections including hidden ones
redis-cli INFO all

# Everything including debug sections
redis-cli INFO everything

Key INFO Sections

server — Redis version, process ID, uptime, architecture, TCP port, config file memory — Used memory, peak memory, fragmentation ratio, total system memory keyspace — Key counts per database (e.g., db0:keys=1000,expires=50,avg_ttl=3600) clients — Connected clients, blocked clients, max clients replication — Role (master/replica), connected replicas, replication offset stats — Total connections, commands processed, keyspace hits/misses persistence — RDB/AOF status, last save time, current save progress cpu — User/system CPU time consumed by Redis

Useful INFO Queries

# Check memory usage and fragmentation
redis-cli INFO memory | grep -E "used_memory_human|fragmentation_ratio"

# Monitor keyspace changes
redis-cli INFO keyspace

# Check replication health
redis-cli INFO replication | grep -E "role|connected_slaves|master_repl_offset"

# Track hit rate
redis-cli INFO stats | grep -E "keyspace_hits|keyspace_misses"

# Watch specific metric over time
redis-cli -r -1 -i 5 INFO memory | grep used_memory_human

Continuous Stats Mode

Rolling display of server statistics updated every second (configurable with -i).

redis-cli --stat

# Change update interval
redis-cli --stat -i 5    # every 5 seconds

Output columns:

------- data ------ --------------------- load -------------------- - child -
keys       mem      clients blocked requests            connections
506        1015.00K 1       0       24 (+0)             7
506        1015.00K 1       0       25 (+1)             7

keys: Total key count
mem: Memory usage
clients: Connected clients
blocked: Blocked clients
requests: Total processed requests (+delta since last line)
connections: Total connections since startup

The delta in parentheses makes it easy to spot sudden traffic spikes.

MONITOR Command

Streams all commands processed by the Redis server in real time.

redis-cli MONITOR

Output format:

1460100081.165665 [0 127.0.0.1:51706] "set" "shipment:8000736522714:status" "sorting"
1460100083.053365 [0 127.0.0.1:51707] "get" "shipment:8000736522714:status"

Fields: timestamp [db client_addr] "command" "arg1" "arg2" ...

Warning: MONITOR adds significant overhead (each command is also sent to MONITOR clients). Avoid running it for extended periods on busy production servers.

Useful for debugging — pipe through grep to filter:

redis-cli MONITOR | grep "SET"
redis-cli MONITOR | grep "user:"

Latency Analysis

Redis provides multiple latency tools for different diagnostic scenarios.

Basic Latency (--latency)

Continuously sends PING and measures round-trip time (100 samples/sec):

redis-cli --latency
# min: 0, max: 1, avg: 0.19 (427 samples)

Stats are in milliseconds. When not in a TTY (or with --raw), samples for 1 second then exits with a single output line.

Latency History (--latency-history)

Same as --latency but resets statistics every 15 seconds (configurable):

redis-cli --latency-history
redis-cli --latency-history -i 30    # 30-second windows

Latency Distribution (--latency-dist)

Color-coded spectrum visualization of latency distribution:

redis-cli --latency-dist

Requires xterm 256-color terminal. Default 1-second interval, change with -i.

Intrinsic Latency (--intrinsic-latency)

Measures the baseline latency of the system (kernel scheduler, hypervisor), not Redis itself.

# Run ON THE SAME MACHINE as Redis, not remotely
redis-cli --intrinsic-latency 5

The argument is the test duration in seconds. Output:

Max latency so far: 739 microseconds.
65433042 total runs (avg latency: 0.0764 microseconds).
Worst run took 9671x longer than the average latency.

This tells you the minimum achievable latency on this system. Redis cannot outperform this baseline.

LATENCY Command (Redis Internal)

Redis also tracks slow events internally:

redis-cli LATENCY LATEST              # Latest latency spikes per event
redis-cli LATENCY HISTORY event-name  # Time-series data for an event
redis-cli LATENCY GRAPH event-name    # ASCII graph of latency over time
redis-cli LATENCY RESET [event ...]   # Reset latency data
redis-cli LATENCY DOCTOR              # Diagnose latency issues

Common event names: command, fork, rdb-unlink, aof-write, aof-fsync-always.

RDB Backup

Transfer an RDB dump file from a remote Redis instance to the local machine.

redis-cli --rdb /tmp/dump.rdb
# SYNC sent to master, writing 13256 bytes to '/tmp/dump.rdb'
# Transfer finished with success.

Check exit code for errors:

redis-cli --rdb /tmp/dump.rdb
echo $?    # 0 = success, non-zero = error

Functions-only RDB (skip key data):

redis-cli --functions-rdb /tmp/functions.rdb

Useful for automated backup scripts and cron jobs. The RDB file can be loaded by any Redis instance.

Replica Mode

Simulates a replica to inspect the replication stream from a master:

redis-cli --replica

Output shows commands as they are replicated in CSV format:

SYNC with master, discarding 13256 bytes of bulk transfer...
SYNC done. Logging commands from master.
"PING"
"SELECT","0"
"SET","last_name","Enigk"
"INCR","mycounter"

Useful for debugging replication issues and understanding what data is being sent to replicas.

LRU Simulation

Simulates cache behavior to help determine the optimal maxmemory setting.

# Simulate 10 million keys with LRU eviction
redis-cli --lru-test 10000000

Prerequisites:

Configure maxmemory (e.g., 100mb) in redis.conf
Set maxmemory-policy to allkeys-lru
WARNING: This test uses pipelining and stresses the server — never use on production instances

Output shows hit/miss rates:

156000 Gets/sec | Hits: 4552 (2.92%) | Misses: 151448 (97.08%)
153750 Gets/sec | Hits: 12906 (8.39%) | Misses: 140844 (91.61%)

Use this to find the right maxmemory value for your key count and access pattern (80-20 power law distribution). A miss rate >10% usually means more memory is needed.

Slow Log

The slow log records commands that exceed a configured execution time threshold. This is the first tool to reach for when debugging unexplained latency.

Configuration

# Check current slowlog settings
redis-cli CONFIG GET slowlog*

# slowlog-log-slower-than: threshold in microseconds (negative = disabled)
# slowlog-max-len: maximum number of entries to keep (ring buffer)
redis-cli CONFIG SET slowlog-log-slower-than 10000   # 10ms
redis-cli CONFIG SET slowlog-max-len 128

Querying

# Get recent slow log entries (default: 10)
redis-cli SLOWLOG GET
redis-cli SLOWLOG GET 20              # Last 20 entries

# Each entry format:
# 1) id            — unique entry ID
# 2) timestamp     — Unix timestamp
# 3) duration      — execution time in microseconds
# 4) command       — array: [cmd, arg1, arg2, ...]
# 5) client        — client address:port
# 6) client_name   — client name (via CLIENT SETNAME)

# Get entry count
redis-cli SLOWLOG LEN

# Reset (clear all entries)
redis-cli SLOWLOG RESET

Useful SLOWLOG Queries

# Find slowest commands
redis-cli SLOWLOG GET 50 | grep -E "^\d+\)|^\d+\) \(integer\)"

# Monitor slow log continuously
redis-cli -r -1 -i 10 SLOWLOG GET 5

# Combine with LATENCY for deeper analysis
redis-cli LATENCY LATEST
redis-cli SLOWLOG GET 10

8.3 KiB Raw Blame History