Redis tools

Redis tools: key view and streams, IntelliSense, Cluster and Sentinel, profiler, Pub/Sub, memory analysis, bulk actions, ACL users, and value formats.

Redis gets its own set of tools beside the key browser. Two watch the server live on a dedicated connection, and the rest answer the admin questions Redis users ask most: where the memory went, how to clean up keys by the thousand, what a binary value actually holds, and whether the slow log is catching anything.

They work on Redis and the servers that speak its protocol - Valkey, KeyDB, DragonflyDB, Amazon ElastiCache, and Amazon MemoryDB, and on Redis Cluster (including ElastiCache cluster mode and MemoryDB), where commands are routed to the node that owns each key's slot, see Redis Cluster.

Connection diagnostics

Test Connection on a Redis connection walks the connection one step at a time and writes each step to the diagnostic log as it finishes, so you can see exactly how far it got. Open the log with ⌘⇧L (Ctrl+Shift+L); set Preferences › Advanced › Log level to Verbose to see every step, a failing step is logged at Errors only too. When a step fails, the error in the connection editor starts with that step - TLS failed: …, AUTH failed: … - instead of a generic "could not connect".

StepWhat it tells you
DatabaseNew Query, Filter Keys…, Clear Key Filter, Scan more; a Bulk Edit submenu with Delete Keys by Pattern… and Set TTL by Pattern…; Import / Export with Import Command File… and Export as Command File…; Tools with Memory Analyzer…, Cluster Topology… (on a cluster), Profiler…, Pub/Sub…, Server Dashboard, Activity Monitor, Query Insights, Disk Usage, Query History, and Security (the ACL page); then Copy Name, Rename… and Show Only Databases… to name and pick the databases you see, and Refresh.
Key folderCopy SCAN Command, Scan more, Delete Keys in Folder…, Set TTL in Folder…, Export Folder as Command File….
KeyOpen Value (the key view), Open in Query Tab; Rename…, an Expiry submenu with Set TTL… and Remove expiry (PERSIST), and Copy To with Copy to Database… and Copy to Connection…; Copy with Copy Name and Copy Command; Delete Key….
Search indexOpen (FT.INFO), Query…, Explain…, Profile…, Drop Index….
Note rowLoad more, Scan more.

How SQLly's connections behave

  • RESP3 when the server has it. SQLly asks for the RESP3 protocol and quietly stays on RESP2 when the server does not offer it. Results look the same either way. SQLLY.SERVERINFO reports which one the connection uses.
  • Every connection has a name. Query tabs, the Profiler and the Pub/Sub viewer name their connections sqlly:<connection name>:<process id>, so CLIENT LIST and the Activity Monitor's Sessions tab show which ones are SQLly's - including the Profiler's own MONITOR connection. A server or ACL that refuses CLIENT SETNAME just leaves them unnamed. (On a server without RESP3, the Pub/Sub viewer's connection cannot be named.)
  • A command timeout. A command that gets no reply within the connection's Query timeout - 30 seconds when it is blank, no limit when it is 0 - fails with a message naming the command and the limit. Blocking commands get the wait you asked for on top, so BLPOP jobs 20 is never cut short. The command may still finish on the server, so SQLly never runs it again for you. The Profiler and Pub/Sub viewer wait without a limit.
  • SSH tunnels stay up. A tunnel sends an SSH keepalive every 30 seconds of silence (set Keepalive (seconds) in the tunnel settings; 0 turns it off), so idle tunnels survive firewalls and NAT timeouts. If the SSH session drops anyway, the next run opens a new tunnel and its Messages say Tunnel re-established. Nothing is re-run on your behalf, check whether the command that was running when the tunnel dropped took effect before you run it again.

The key browser

Redis has no catalog, so its part of the explorer is built from the keys themselves. Expand a Redis server and you get its logical databases - db0, db1, and so on, each with a key count. Expand a database and SQLly lists its keys with one bounded SCAN walk (never KEYS *), folding them into folders on the connection's key delimiters: user:42:profile lands in user › 42. The delimiter is : unless you set others in the connection editor's Key delimiters field. Type several characters to split on each of them - :| folds both user:42 and cache|en|home - or separate longer delimiters with spaces (:: |); a single character, or one repeated like ::, keeps meaning exactly that. Each key shows its type and, when it has one, its time to live.

A listing can be cut short in two ways, and one note row at the bottom covers both. A walk stops at 10,000 keys, and the tree shows the first 2,000 rows of what it scanned. The note says what is shown of what was scanned and whether the scan itself stopped, for example Showing 2,000 of 7,350 rows from 10,000 scanned keys; the SCAN stopped there. Click the note to load more rows (no rescan, they were already walked), or choose Scan more on the note, the database or a folder to continue the same SCAN from where it stopped; the new keys join the rows already shown and folder counts update. Use Filter Keys… to narrow the listing to a pattern and Clear Key Filter to go back. The filter is remembered per database on the connection, so it is back in force the next time you open the app, and the Filter Keys… dialog offers the last five patterns you typed on that connection in a Recent dropdown. Folders re-scan their own prefix when you expand them, so deep trees load a level at a time.

Filter Keys matches key names with a glob such as user:*; it never looks inside values. If you type something that reads as a value query - JSON such as {"name": "bob"} or a search query such as @name:bob - the dialog says so instead of quietly listing nothing, and offers Search values with FT.SEARCH…. On a server with the search module and an index, that opens a query tab with an FT.SEARCH over the first index (the others are named in a comment), turning JSON fields into @field:"value" clauses for you to review and run; without an index or the module, the dialog explains what is needed. Cluster hash tags like {user1}:* are ordinary patterns and never trigger the hint.

Key listings in a query tab

When you want to sort or filter keys rather than browse them, run SQLLY.KEYS <pattern> <limit> in a query tab, for example SQLLY.KEYS session:* 5000. It walks the keyspace with the same bounded SCAN as the explorer and returns a normal grid with key, type and ttl_seconds columns, so you can click the ttl_seconds header to sort by time to live or use Filter Rows… to keep, say, keys with no expiry or under an hour left.

Then act on what you found: select rows (or the whole key column), right-click, and open Tools › Redis Keys for Delete Selected Keys…, Set TTL on Selected Keys… or Remove Expiry from Selected Keys…. The dialog lists the selected keys first, a delete asks you to type the key count back, and nothing writes on a read-only or locked production connection, the same gates as the bulk actions. The same menu appears on the Memory Analyzer's top-keys report shape (SQLLY.TOPKEYS) and on SQLLY.KEYINFO; results whose key column is not a key name, such as INFO, never offer it. The keys act on the connection and database the tab runs against.

Each database row shows its key count and, when any key has an expiry, how many - 120 keys · expires: 7 - straight from the server's keyspace statistics. Opening a list, sorted set or stream reads its first 1,000 elements, and the tab is named that way (orders — first 1,000) so a long value is never mistaken for the whole thing.

SQLly
SQLLY key browser listing Redis databases 0 to 15 for Session Cache, with key countsSQLLY key browser listing Redis databases 0 to 15 for Session Cache, with key counts
The key browser for Session Cache: each Redis database with its key count and expiry summary.

What the right-click menus offer

On a…You can
DatabaseNew Query, Filter Keys…, Clear Key Filter, Scan more; Bulk Edit (Delete Keys by Pattern…, Set TTL by Pattern…); Import / Export (Import Command File…, Export as Command File…); and Tools with Memory Analyzer…, Profiler…, Pub/Sub…, Server Dashboard, Activity Monitor, Query Insights, Disk Usage, and Query History.
Key folderCopy SCAN Command, Scan more, Delete Keys in Folder…, Set TTL in Folder….
KeyOpen Value, Open in Query Tab; Rename…, Expiry (Set TTL…, Remove expiry (PERSIST)), Copy To; Copy (Copy Name, Copy Command); Delete Key….
Note rowLoad more, Scan more.

The writing entries - deletes, TTL changes, renames, copies, and imports - are greyed out on a connection set to Block all but SELECT, and a locked production connection asks you to unlock writes first.

In a query tab, a Redis connection runs one command per line. Command IntelliSense completes commands, options, subcommands and key names; SQL validation and the formatter do not apply.

Read and change keys

Open a key in the key view to page through its value and edit it with the command shown first; a stream key adds tabs for its consumer groups and pending entries. In a query tab, command IntelliSense completes commands, options and key names, and Redis Stack replies come back as tables.

Key view
Open a key as a view: header strip, paged value, and per-type edits that show the exact command before they run.
Streams and consumer groups
Page through a stream, see groups, consumers, pending entries and lag, and run reviewed stream commands from the key view.
Command IntelliSense
Complete commands, options, subcommands and scanned key names, with syntax and safety badges on hover.
Redis Stack modules
JSON, Search, TimeSeries, and the probabilistic types as real grids, plus the search index browser in the explorer.

Connect to clusters and Sentinel

A connection can route commands across a Redis Cluster, including ElastiCache cluster mode and MemoryDB, or find the current master through Sentinel and follow failovers.

Redis Cluster
Redis Cluster, ElastiCache cluster mode and MemoryDB: slot routing, a node map for unreachable node addresses, per-node SSH forwards, and topology.
Sentinel
Connect through Redis Sentinel by master name, read from replicas, and survive failovers.

Watch it live

Reach for these when you need to see traffic as it happens: the Profiler to find out which client is hammering a key, the Pub/Sub viewer to check that messages are being published where you expect. Both are tabs in the Activity Monitor and run in the desktop app only.

Profiler
A bounded, time-boxed MONITOR capture on its own connection, with pause, filters, and a hard stop.
Pub/Sub viewer
Subscribe to channels, patterns, or every key event on a database and watch messages arrive live.

Look after it

Start with Tools › Disk Usage for memory per database, then the memory analyzer to see which types and keys account for it. Bulk actions clean up what you find, value formats decode what a key actually holds, and the slow log page covers the threshold that decides which commands get logged.

Memory analyzer
Memory by data type, the biggest keys, and a TTL histogram from a bounded sample.
Bulk actions
Delete or expire keys by pattern with a dry-run count first, and import command files.
ACL users
See every ACL user and the recent access denials, and script reviewed ACL SETUSER / ACL DELUSER changes.
Value formats
View a value as UTF-8, JSON, hex, MessagePack, Base64, Protobuf, or decompressed gzip, zstd and LZ4, with your pick remembered per key.
Slow log threshold
See the slow-log threshold and change it through a reviewed CONFIG SET.

The live tools open their own connection and always have a cap and a stop, so leaving one open cannot fill your memory or tie up the connection your queries use. The memory analyzer's sample and the bulk actions' dry-run count have a Stop too: a stopped sample keeps the previous reports on screen, and a stopped count is labelled partial.