Redis

redis-cli slowlog get 10                  # commands over slowlog-log-slower-than (default 10000 µs)
redis-cli --latency-history -i 5          # PING round trip, a new sample window every 5 s
redis-cli info stats | grep -E 'instantaneous_ops|keyspace_(hits|misses)|evicted_keys|expired_keys'
redis-cli info persistence | grep -E 'rdb_bgsave_in_progress|aof_rewrite_in_progress|latest_fork_usec'
redis-cli info memory | grep -E 'used_memory_human|maxmemory_human|mem_fragmentation_ratio'
redis-cli latency doctor                  # needs latency-monitor-threshold > 0

redis-cli info commandstats | sed 's/cmdstat_//' | sort -t= -k2 -rn | head   # most-called commands

redis-cli set session:123 '{"u":7}' ex 3600 nx         # set with a 1 h TTL, only if absent
redis-cli hset user:7 name alice email alice@example.com
redis-cli lpush jobs '{"id":1}'
redis-cli brpop jobs 5                                  # block up to 5 s for an item
redis-cli zadd scores 42 alice
redis-cli zrange scores 0 9 rev withscores              # top 10; REV needs Redis 6.2+
redis-cli xadd events maxlen '~' 100000 '*' type deploy service my-app

redis-cli object encoding user:7    # listpack, hashtable, intset, skiplist, quicklist...

redis-cli ttl session:123          # -1 = no expiry, -2 = key does not exist
redis-cli expire session:123 600
redis-cli persist session:123      # remove the TTL
redis-cli config get maxmemory maxmemory-policy
redis-cli config set maxmemory-policy allkeys-lru   # runtime only; also update redis.conf or CONFIG REWRITE

redis-cli config get save appendonly appendfsync
redis-cli bgsave
redis-cli info persistence | grep -E 'rdb_last_bgsave_status|aof_last_write_status|latest_fork_usec'
redis-cli bgrewriteaof
redis-cli --rdb /backup/dump.rdb      # pull an RDB snapshot to the local machine

cat /sys/kernel/mm/transparent_hugepage/enabled    # Redis docs recommend [never]
sysctl vm.overcommit_memory                        # expect 1

redis-cli --scan --pattern 'session:*' --count 1000 | head
redis-cli --bigkeys          # largest key per type by element count, uses SCAN
redis-cli --memkeys          # largest key per type by memory
redis-cli --keystats         # both, plus size distribution (recent redis-cli)
redis-cli memory usage session:123
redis-cli info keyspace
redis-cli dbsize

TOKEN=$(uuidgen)
redis-cli set lock:deploy "$TOKEN" nx ex 30      # OK = acquired, (nil) = held by someone else

-- release.lua: delete only if we still own the lock
if redis.call("get", KEYS[1]) == ARGV[1] then
  return redis.call("del", KEYS[1])
end
return 0

redis-cli --eval release.lua lock:deploy , "$TOKEN"   # keys before the comma, arguments after

redis-cli info replication                            # role, master_link_status, offsets, replicas
redis-cli --cluster check host.example.com:6379
redis-cli --cluster info host.example.com:6379
redis-cli -h host.example.com cluster info            # cluster_state:ok, slots assigned and failing
redis-cli -c -h host.example.com get user:7           # -c follows MOVED and ASK redirects

redis-cli xadd events '*' type deploy service my-app        # append; * = server-assigned ID
redis-cli xlen events
redis-cli xrange events - + count 5                         # oldest 5 (- and + are min/max IDs)
redis-cli xrevrange events + - count 5                      # newest 5

redis-cli xgroup create events workers '$' mkstream         # group reads only new messages; mkstream if absent
redis-cli xreadgroup group workers worker-1 count 10 block 5000 streams events '>'   # '>' = undelivered
redis-cli xack events workers 1700000000000-0              # acknowledge one processed message

redis-cli xpending events workers                          # summary: count, min/max ID, per-consumer
redis-cli xautoclaim events workers worker-2 60000 0       # claim messages idle > 60 s (Redis 6.2+)
redis-cli xinfo groups events                              # last-delivered ID, lag, pending per group
redis-cli xadd events maxlen '~' 100000 '*' k v            # cap length approximately on write; ~ is far cheaper

# MULTI/EXEC: queued commands run atomically, but there is no rollback and no reading a value mid-transaction
printf 'MULTI\nINCR a\nINCR b\nEXEC\n' | redis-cli

{ for i in $(seq 1 100000); do printf 'SET k:%d %d\n' "$i" "$i"; done; } | redis-cli --pipe

-- incr_with_cap.lua: increment KEYS[1], but never above ARGV[1]
local cur = tonumber(redis.call('get', KEYS[1]) or '0')
if cur >= tonumber(ARGV[1]) then return cur end
return redis.call('incr', KEYS[1])

redis-cli --eval incr_with_cap.lua counter , 100          # keys before comma, args after
redis-cli script load "$(cat incr_with_cap.lua)"          # returns a SHA; run later with EVALSHA

redis-cli -p 26379 sentinel masters                       # monitored primaries and their state
redis-cli -p 26379 sentinel master mymaster               # detail: flags, quorum, num-slaves
redis-cli -p 26379 sentinel replicas mymaster
redis-cli -p 26379 sentinel get-master-addr-by-name mymaster   # what clients should connect to now
redis-cli -p 26379 sentinel ckquorum mymaster             # can this Sentinel reach quorum to fail over?
redis-cli -p 26379 sentinel failover mymaster             # force a manual failover (for testing)

redis-cli info stats     | grep -E 'total_commands|instantaneous_ops|keyspace_(hits|misses)|expired|evicted|rejected'
redis-cli info memory    | grep -E 'used_memory_human|used_memory_peak_human|maxmemory_human|mem_fragmentation_ratio|mem_clients'
redis-cli info clients   | grep -E 'connected_clients|blocked_clients|maxclients'
redis-cli info persistence | grep -E 'rdb_last_save_time|rdb_last_bgsave_status|aof_enabled|aof_last_bgrewrite_status'
redis-cli info replication | grep -E 'role|connected_slaves|master_repl_offset'

redis-cli slowlog get 10          # id, timestamp, microseconds, command, client
redis-cli slowlog reset
redis-cli memory doctor
redis-cli memory stats | head -30
redis-cli latency reset && redis-cli latency latest

redis-cli info clients | grep -E 'connected_clients|blocked_clients|maxclients'
redis-cli client list | head                       # one line per client: addr, age, idle, cmd
redis-cli client kill id 42                        # disconnect one client
redis-cli acl log 10                               # recent auth and permission failures

# Key count by prefix, without blocking
redis-cli --scan --count 1000 | awk -F: '{print $1}' | sort | uniq -c | sort -rn | head

# Keys under a prefix with no TTL (possible leak); one TTL call per key, keep it bounded
redis-cli --scan --pattern 'cache:*' | head -10000 | while read -r k; do [ "$(redis-cli ttl "$k")" = -1 ] && echo "$k"; done | head

# Cache hit ratio
redis-cli info stats | tr -d '\r' | awk -F: '/^keyspace_(hits|misses)/ {a[$1]=$2} END {t=a["keyspace_hits"]+a["keyspace_misses"]; if (t) printf "%.2f%%\n", 100*a["keyspace_hits"]/t}'

# Delete keys matching a pattern in batches, reclaiming memory in the background
redis-cli --scan --pattern 'tmp:*' | xargs -r -L 500 redis-cli unlink

# Copy one key to another instance (db 0, 5000 ms timeout), keeping the source
redis-cli migrate target.example.com 6379 mykey 0 5000 copy replace

# Confirm a replica is healthy before promoting it
redis-cli -h replica.example.com info replication | grep -E 'role|master_link_status|master_last_io_seconds_ago'

# Benchmark GET/SET with pipelining (not against production)
redis-benchmark -h host.example.com -t get,set -n 100000 -P 16 -q

# Total keys across every database
redis-cli info keyspace | awk -F'[:,=]' '/^db/ {s+=$3} END {print s+0}'

# Memory used by every key under a prefix (bounded; one MEMORY USAGE per key)
redis-cli --scan --pattern 'cache:*' | head -5000 | while read -r k; do redis-cli memory usage "$k"; done | awk '{s+=$1} END {printf "%.1f MB\n", s/1048576}'

# Set a TTL on every key under a prefix that currently has none
redis-cli --scan --pattern 'session:*' | while read -r k; do [ "$(redis-cli ttl "$k")" = -1 ] && redis-cli expire "$k" 3600; done

# Top 10 commands by call count
redis-cli info commandstats | sed 's/cmdstat_//' | awk -F'[:,=]' '{print $3, $1}' | sort -rn | head

# Ops per second sampled once
redis-cli info stats | awk -F: '/instantaneous_ops_per_sec/ {print $2+0}'

# Watch memory fragmentation live
watch -n2 "redis-cli info memory | grep -E 'used_memory_human|mem_fragmentation_ratio'"

# Every client blocked on a blocking command
redis-cli client list | awk -F'[ =]' '{for(i=1;i<=NF;i++) if($i=="cmd" && $(i+1) ~ /b(lpop|rpop|zpopmin)/) print}'

# Persist the current config to redis.conf after a runtime CONFIG SET
redis-cli config rewrite

# Rename a dangerous command check (see if FLUSHALL is disabled)
redis-cli config get 'rename-command' 2>/dev/null; redis-cli command info flushall | head -2

# Slot a key maps to in Cluster mode
redis-cli -h host.example.com cluster keyslot user:7

# Which node owns a slot
redis-cli -h host.example.com cluster shards | head -20

# Approximate distinct count with HyperLogLog
redis-cli pfadd visitors user:1 user:2 user:3 && redis-cli pfcount visitors

#!/usr/bin/env bash
set -euo pipefail
limit=${1:-10000}
redis-cli --scan --count 1000 | head -n "$limit" |
while IFS= read -r key; do
  bytes=$(redis-cli memory usage "$key" 2>/dev/null || echo 0)
  enc=$(redis-cli object encoding "$key" 2>/dev/null || echo '-')
  printf '%d\t%s\t%s\n' "${bytes:-0}" "$enc" "$key"
done | sort -rn | head -20 |
awk -F'\t' '{printf "%10.1f KB  %-10s %s\n", $1/1024, $2, $3}'

#!/usr/bin/env bash
set -euo pipefail
pattern=${1:?usage: redis-purge.sh <pattern> [batch]}
batch=${2:-500}
total=0
redis-cli --scan --pattern "$pattern" --count "$batch" |
while mapfile -t -n "$batch" keys && ((${#keys[@]})); do
  redis-cli unlink "${keys[@]}" >/dev/null
  total=$((total + ${#keys[@]}))
  printf 'deleted %d\n' "$total"
  sleep 0.05
done

#!/usr/bin/env bash
set -euo pipefail
host=${1:?usage: redis-replica-check.sh <replica-host> [max_lag_s]}
max_lag=${2:-5}
info=$(redis-cli -h "$host" info replication | tr -d '\r')

role=$(awk -F: '/^role:/ {print $2}' <<<"$info")
link=$(awk -F: '/^master_link_status:/ {print $2}' <<<"$info")
lag=$(awk -F: '/^master_last_io_seconds_ago:/ {print $2+0}' <<<"$info")

[[ $role == slave ]]      || { echo "not a replica (role=$role)"; exit 1; }
[[ $link == up ]]         || { echo "master link down"; exit 1; }
(( lag <= max_lag ))      || { echo "lag ${lag}s exceeds ${max_lag}s"; exit 1; }
echo "ok: replica healthy, last IO ${lag}s ago"