opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/redis-cli/references/inspection-and-monitoring.md

@@ -0,0 +1,309 @@
+# Inspection and Monitoring
+
+## Table of Contents
+
+- [INFO Command](#info-command)
+- [Continuous Stats Mode](#continuous-stats-mode)
+- [MONITOR Command](#monitor-command)
+- [Latency Analysis](#latency-analysis)
+- [RDB Backup](#rdb-backup)
+- [Replica Mode](#replica-mode)
+- [LRU Simulation](#lru-simulation)
+- [Slow Log](#slow-log)
+
+## INFO Command
+
+Returns server information and statistics as key-value pairs organized in sections.
+
+```bash
+# 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
+
+```bash
+# 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`).
+
+```bash
+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.
+
+```bash
+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:
+```bash
+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):
+
+```bash
+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):
+
+```bash
+redis-cli --latency-history
+redis-cli --latency-history -i 30    # 30-second windows
+```
+
+### Latency Distribution (--latency-dist)
+
+Color-coded spectrum visualization of latency distribution:
+
+```bash
+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.
+
+```bash
+# 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:
+
+```bash
+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.
+
+```bash
+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:
+```bash
+redis-cli --rdb /tmp/dump.rdb
+echo $?    # 0 = success, non-zero = error
+```
+
+**Functions-only RDB** (skip key data):
+```bash
+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:
+
+```bash
+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.
+
+```bash
+# 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
+
+```bash
+# 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
+
+```bash
+# 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
+
+```bash
+# 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
+```

package/bundled-skills/redis-cli/references/key-management.md

@@ -0,0 +1,252 @@
+# Key Management
+
+## Table of Contents
+
+- [SCAN Family](#scan-family)
+- [Built-in Scan Modes](#built-in-scan-modes)
+- [Big Keys Analysis](#big-keys-analysis)
+- [Memory Usage Analysis](#memory-usage-analysis)
+- [Combined Analysis](#combined-analysis-keystats)
+- [Hot Keys Detection](#hot-keys-detection)
+- [Key Expiration Management](#key-expiration-management)
+- [Mass Insertion](#mass-insertion)
+
+## SCAN Family
+
+The SCAN family provides production-safe iteration over collections. Unlike `KEYS *` or `SMEMBERS` which block the server on large datasets, SCAN returns small batches incrementally.
+
+### SCAN Command Reference
+
+| Command | Iterates Over | Syntax |
+|---------|--------------|--------|
+| `SCAN` | Keys in database | `SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]` |
+| `SSCAN` | Members of a Set | `SSCAN key cursor [MATCH pattern] [COUNT count]` |
+| `HSCAN` | Fields of a Hash | `HSCAN key cursor [MATCH pattern] [COUNT count] [NOVALUES]` |
+| `ZSCAN` | Members of a Sorted Set | `ZSCAN key cursor [MATCH pattern] [COUNT count]` |
+
+### How SCAN Works
+
+1. Start iteration with cursor `0`
+2. Each call returns `[new_cursor, [elements...]]`
+3. Use `new_cursor` in the next call
+4. Iteration is complete when cursor returns `0`
+
+```
+# Full iteration example
+SCAN 0 MATCH user:* COUNT 100
+# Returns: 1) "42"  2) ["user:1", "user:5", "user:23"]
+SCAN 42 MATCH user:* COUNT 100
+# Returns: 1) "0"   2) ["user:88", "user:91"]    ← iteration complete (cursor=0)
+```
+
+### SCAN Options
+
+**MATCH pattern** — Glob-style filtering applied *after* retrieval (not server-side filtering):
+- `*` matches any sequence
+- `?` matches single character
+- `[ae]` matches one of the characters
+- Important: because MATCH is applied post-retrieval, some iterations may return empty results. Increase `COUNT` to compensate.
+
+**COUNT n** — Hint for number of elements per call (default: 10):
+- This is a *hint*, not a guarantee
+- For small collections encoded as ziplists/intsets, all elements may be returned in one call regardless of COUNT
+- The key space (SCAN) always uses hash tables and respects COUNT more predictably
+- You can change COUNT between calls without affecting iteration correctness
+
+**TYPE type** — Filter by data type (SCAN only, Redis 6.0+):
+- `SCAN 0 TYPE hash` returns only hash keys
+- Type is the same string that `TYPE` command returns: `string`, `list`, `set`, `zset`, `hash`, `stream`
+- Like MATCH, this is applied post-retrieval
+
+**NOVALUES** — Return field names only, without values (HSCAN only):
+- `HSCAN myhash 0 NOVALUES` returns just field names, saving bandwidth for large hashes
+
+### SCAN Guarantees
+
+A full iteration (cursor 0 → 0) provides:
+
+1. **Completeness**: All elements that existed for the entire duration of the iteration will be returned at least once
+2. **No false positives**: Elements that never existed during the iteration are never returned
+
+### SCAN Limitations
+
+- Elements may be returned **multiple times** — handle deduplication in your application
+- Elements added or removed during iteration may or may not appear — undefined behavior
+- Only valid cursors are `0` (start) or values returned by previous SCAN calls
+- An iteration over a collection that grows faster than SCAN progresses may never terminate
+
+### SCAN in Redis Cluster
+
+In cluster mode, SCAN only iterates keys in the current node's slot range. The `--scan` option in redis-cli handles cluster iteration automatically across all nodes.
+
+Pattern matching is optimized for patterns implying a single slot. For example, `{a}h*llo` only scans keys in slot 15495 (hash tag `{a}`).
+
+## Built-in Scan Modes
+
+redis-cli provides built-in scan modes that wrap the SCAN command:
+
+```bash
+# List all keys
+redis-cli --scan
+
+# Filter by glob pattern
+redis-cli --scan --pattern 'user:*'
+redis-cli --scan --pattern '*-11*'
+
+# Control batch size
+redis-cli --scan --count 100
+
+# Add delay between SCAN calls (reduce server load)
+redis-cli --scan --pattern 'user:*' -i 0.01
+
+# Count keys matching a pattern
+redis-cli --scan --pattern 'session:*' | wc -l
+
+# Chain with other tools
+redis-cli --scan --pattern 'cache:*' | head -20
+redis-cli --scan --pattern 'temp:*' | while read key; do redis-cli DEL "$key"; done
+```
+
+## Big Keys Analysis
+
+Scans the entire keyspace to find keys with the most elements (complexity-based).
+
+```bash
+# Find biggest keys by element count
+redis-cli --bigkeys
+
+# Throttle scanning (0.01 sec per 100 SCAN calls)
+redis-cli --bigkeys -i 0.01
+
+# Filter by pattern
+redis-cli --bigkeys --pattern 'user:*'
+```
+
+Output example:
+```
+# Scanning the entire keyspace...
+Biggest   list found "bikes:finished" has 1 items
+Biggest string found "all_bikes" has 36 bytes
+Biggest   hash found "bike:1:stats" has 3 fields
+Biggest stream found "race:france" has 4 entries
+
+-------- summary -------
+Total key length in bytes is 495 (avg len 9.00)
+
+1 lists with 1 items (01.82% of keys, avg size 1.00)
+16 strings with 149 bytes (29.09% of keys, avg size 9.31)
+```
+
+Reports biggest key per type, percentage of keys per type, and average sizes. Works on cluster replicas.
+
+## Memory Usage Analysis
+
+Scans for keys consuming the most memory.
+
+```bash
+# Find keys by memory consumption
+redis-cli --memkeys
+
+# With throttling
+redis-cli --memkeys -i 0.01
+
+# Custom sample count for nested types
+redis-cli --memkeys --memkeys-samples 10
+```
+
+Output is similar to `--bigkeys` but reports byte sizes instead of element counts.
+
+## Combined Analysis (--keystats)
+
+Combines `--bigkeys` and `--memkeys` with distribution data.
+
+```bash
+redis-cli --keystats
+redis-cli --keystats --top 20         # Show top 20 keys
+redis-cli --keystats --cursor 12345   # Resume from a previous scan
+redis-cli --keystats -i 0.01          # Throttled
+```
+
+Output includes:
+- Top N key sizes ranked by memory
+- Biggest key per type (by size and by element count)
+- Percentile distribution of key sizes
+- Per-type statistics (total keys, percentage, total size, average size)
+
+## Hot Keys Detection
+
+Identifies frequently accessed keys. Requires `maxmemory-policy` to be set to an LFU variant.
+
+```bash
+redis-cli --hotkeys
+```
+
+## Key Expiration Management
+
+### Setting Expiry
+
+```bash
+# Set TTL in seconds
+redis-cli EXPIRE mykey 3600
+
+# Set TTL in milliseconds
+redis-cli PEXPIRE mykey 5000
+
+# Set expiry at specific Unix timestamp
+redis-cli EXPIREAT mykey 1735689600
+
+# Conditional expiry (Redis 7.0+)
+redis-cli EXPIRE mykey 3600 NX        # Only if no current expiry
+redis-cli EXPIRE mykey 3600 XX        # Only if already has expiry
+redis-cli EXPIRE mykey 3600 GT        # Only if new TTL > current TTL
+redis-cli EXPIRE mykey 3600 LT        # Only if new TTL < current TTL
+```
+
+### Checking Expiry
+
+```bash
+redis-cli TTL mykey                    # Seconds remaining (-1=none, -2=not exists)
+redis-cli PTTL mykey                   # Milliseconds remaining
+redis-cli EXPIRETIME mykey             # Unix timestamp of expiry
+```
+
+### Removing Expiry
+
+```bash
+redis-cli PERSIST mykey                # Make key permanent
+```
+
+### Hash Field Expiry (Redis 7.4+)
+
+```bash
+redis-cli HEXPIRE myhash 3600 FIELDS 2 field1 field2
+redis-cli HTTL myhash 2 field1 field2
+redis-cli HPERSIST myhash FIELDS 2 field1 field2
+```
+
+### Expiry Behavior
+
+- Setting a key with `SET`, `GETSET`, or `*STORE` commands clears any existing TTL
+- `DEL`, `RENAME`, and `MOVE` transfer or clear the TTL
+- `EXPIRE` on a key with existing TTL updates the timeout
+- Expired keys are deleted lazily or actively sampled (~10 times/sec, random sample of 20 keys)
+
+## Mass Insertion
+
+For bulk loading data into Redis, use the pipe mode which is significantly faster than individual commands.
+
+```bash
+# Generate Redis protocol from data and pipe it
+cat data.txt | redis-cli --pipe
+
+# With custom timeout (default 30 seconds)
+cat data.txt | redis-cli --pipe --pipe-timeout 60
+
+# The input file must use Redis protocol format:
+# *<args>\r\n$<len>\r\n<arg>\r\n...
+#
+# Example for SET key value:
+# *3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n
+```
+
+See the [official mass insertion guide](https://redis.io/docs/latest/develop/clients/patterns/bulk-loading/) for generating protocol files from CSV or other data sources.