Redis checks

Every check Verbiqo can run on Redis 6 and later, Valkey and KeyDB (and Dragonfly from Verbiqo 0.1.26), grouped by area. You ask in plain words; the model says which areas the question needs, and Verbiqo runs those checks first. A failed snapshot, a broken replica link, memory at its limit or a cluster that cannot serve every slot is reported on any question.

How to read this page. Each section is one area. Why it helps says what you get from it. Ask is a question to type that runs it. The table under it lists what Verbiqo checks there: you do not run those one by one. When a check finds a problem, it appears under the answer as a finding, with its evidence and a suggested fix.

How to ask for each area

Ask in your own words. The model reads the question and says which areas it needs; Verbiqo runs those checks before the model reads anything itself. The words below are what Verbiqo goes by when the model cannot say.

Area	Words Verbiqo goes by without the model	Ask, for example
Right now	slow, latency, hanging, stuck, timeouts, busy, CPU, right now, currently, spike, blocked, evicting	Redis is slow right now, why?
Memory, persistence, replication, cluster, clients	memory, maxmemory, eviction, fragmentation, persistence, snapshot, RDB, AOF, backup, replica, replication, primary, cluster, slots, clients, connections, settings, config, keys, expiry, stability, health	Is the replica in sync?
Security	security, secure, password, authentication, ACL, users, TLS, encryption, exposed, harden	Is this Redis secure?
Capacity	capacity, forecast, how long until, fill up, growth, sizing, headroom, planning	When will Redis hit maxmemory?
What happened	what happened, timeline, incident, outage, yesterday, at 3pm, when did, root cause	What happened in the last hour?
What Verbiqo can see	what should I enable, readiness, permissions, ACL	What should I enable?

A broad question, such as health check, runs the review and the security checks; the live sample runs when something is wrong now.

Right now

Why it helps: When Redis is slow now, it shows the slow commands, latency events and clients behind it.

Ask Redis is slow right now, why?

Verbiqo reads the server’s counters twice, 10 seconds apart (see sampling), then the slow log, latency events and clients.

Check	What it looks for
Main thread saturated	The thread that runs commands 90% busy or more: every client waits in turn.
Connections refused	Connections turned away during the sample.
Evicting	Keys evicted during the sample to stay under maxmemory.
Blocking command	`KEYS`, whole reads of large collections, scripts and the like in the last hour’s slow log, with the client. For `KEYS`, the `SCAN` to use instead.
Slow commands	The slowest of the others.
Latency events	Forks, AOF writes, expiry and slow commands of 100 ms or more in the last hour.
Large output buffer	A replica, subscriber or client with 32 MB or more waiting to be sent.

Memory, persistence, replication, cluster and clients

Why it helps: Checks memory, persistence, replication, cluster and clients together, so you hear about eviction, data loss or a broken replica before users do.

Ask Is the replica in sync?

Every review states two things outright, whether or not they are findings, because they are the answers most often guessed:

The role line. Role: primary with 2 replicas connected: 10.0.0.5:6379 online, in sync (lag 0 s); …, Role: primary with no replicas connected, or Role: replica of host:port, link up, last contact 1 s ago. Redis calls a server without a cluster standalone whether or not it has replicas; this line says which.
The restart line. What a restart now would lose: at most about a second of writes (AOF on, with its appendfsync), every write since the last snapshot, 40 min ago with the changes made since, or every key when neither snapshots nor AOF keep the data.

Check	What it looks for
Near maxmemory	90% of maxmemory or more; critical with `noeviction`, where writes then fail.
No maxmemory	No limit, so the operating system kills Redis when the machine runs out.
Fragmentation	Memory held but not used, with `activedefrag` to reclaim it.
Swapping	Part of Redis in swap.
Hit ratio, expiry, forks	Few lookups finding their key, expired keys piling up, forks of half a second or more.
Snapshot or AOF failed	The last `BGSAVE` or AOF write failed: writes may be refused.
Primary without persistence	A primary with replicas that saves nothing: a restart empties them all.
Replica link down	A replica not connected to its primary.
Writable replica	`replica-read-only no`.
Replica behind	A replica not online, or 10 seconds or more behind.
Backlog too small	Reconnections that needed a full resync, with a larger `repl-backlog-size`.
Cluster down	The cluster state not `ok`, with failed nodes and primaries without a replica.
Clients near maxclients	80% of the limit or more, and connections refused since start.
Idle clients	Most clients idle for over an hour, by host: a pool that never closes, or a leak.
Monitoring off	Latency monitoring or the slow log off, TCP keepalive off.

Security

Why it helps: Shows open access, dangerous commands left enabled and missing TLS, so you close the gaps an audit would find.

Ask Is this Redis secure?

Check	What it looks for
No password	A connection without signing in that the server answers (Verbiqo sends only `PING` on it), with the binding and protected mode.
DEBUG or MODULE enabled	Commands that can crash the server or load code.
No TLS	Only unencrypted connections accepted.

Ready-made reports

A report is one fixed reading of one area: no question, no model, the same output every time. Use one to look at an area yourself, or to share what it shows.

From a terminal, it prints the report:

verbiqo redis run cache memory

In verbiqo chat, it loads the report into the conversation so you can ask about it. help lists the reports:

/redis cache memory
/redis cache help

In the desktop apps, there is no report command: ask in your own words, and Verbiqo reads what the question needs.

Report	Shows
`overview`	Version, role, uptime, clients, memory, keys and operations.
`memory`	Used, peak, resident, the limit and eviction policy, fragmentation.
`memory-doctor`	Redis’s own diagnosis of its memory.
`stats`	Operations, hits and misses, evictions, expiries and refused connections since start.
`clients`	Connected clients, the largest buffers and longest idle first.
`connections`	Clients grouped by host, name and user.
`slowlog`	The slowest recent commands, values withheld.
`latency`	Latency events: the latest and worst of each.
`latency-doctor`	Redis’s own diagnosis of its latency.
`replication`	Role, the primary link or each replica, offsets and backlog.
`persistence`	The last snapshot and AOF rewrite, and changes not yet saved.
`keyspace`	Keys, keys with an expiry and average TTL per database.
`commandstats`	Commands by total time, with calls, time per call and failures.
`errorstats`	Errors the server replied with, by kind.
`cluster`	Cluster state, slots and every node.
`settings`	The settings that most often matter, secrets withheld.

The monitoring user is in Set up Redis.