Redis Enterprise Software (RS) includes many useful metrics give you a detailed picture of what is going on in the cluster, node, database, and shard. For Redis on Flash (ROF) databases, additional metrics are available.

Standard Metrics

Metric Components measured Description More information
Connections Cluster, Node, Database Number of connections used to access the database
CPU usage Cluster, Node Percent usage of the CPU
Evicted objects/sec Database, Shard Number of objects evicted per second The eviction process is taken place if:
1. The database reaches its memory_limit;

2. The eviction policy allows eviction; i.e. it is not configured to ‘no-eviction’

3. The dataset keys are compliant with the selected eviction policy. For example: volatile-lru eviction policy, only applied to keys which are violated, such as with TTL set
Expired objects/sec Database, Shard Number of expired objects per second (An expired object is an object with expired TTL that was deleted from the database) This is more relevant for caching use cases.
Redis implements 2 expiry mechanisms:

1. Lazy expiry – on every access to an object Redis first checks whether the object has already been expired by looking at its TTL, and if ‘yes’ Redis deletes it

2. Active expiry – Redis constantly selects random keys and deletes them if it finds they were expired
Fork CPU usage Database, Shard CPU usage of Redis child forks (for replication, BGSAVA...)
Free disk space Cluster, Node Remaining unused disk space
Free ephemeral disk space Cluster, Node Remaining unused disk space on the ephemeral path
Free RAM Cluster, Node Remaining unused RAM memory
Hit ratio Database, Shard Calculated as number of ops on existing keys out of the total number of ops number_of_ops_on_exsiting_keys / total_ops
Incoming traffic Cluster, Node, Database Total incoming traffic (in bytes/sec) to the database
Incoming traffic compressed CRDB Total incoming compressed traffic (in bytes/sec) to the database
Incoming traffic uncompressed CRDB Total incoming uncompressed traffic (in bytes/sec) to the database
Latency Database Latency per operation The graph shows average, min, max and last values are also shown
Main Thread CPU usage Database, Shard Percent usage of the CPU by the main thread
Memory limit Database Memory size limit of the database, enforced on used_memory Note – used memory does not include:
1. Fragmentation ratio
2. Replication buffer – it is auto_slavebuf_ratio % of used_memory.The default auto_slavebuf_ratio is 10%. And there is auto_slavebuf_min and auto_slavebuf_max which are 64MB and 2048MB by default, it will never exceed these in both directions.
3. Lua memory limit which has 2 thresholds:
- A Garbage Collection threshold triggered when Lua memory crosses 0.5GB
- A hard 1GB the Lua will never cross
Memory usage Database Calculated as used memory out of the memory limit used_memory / memory_limit
Ops/sec Cluster, Node, Database, Shard Number of total operations per second Where operations means:
1. read operations
2. write operations
3. other commands operations
Other cmds/sec Database Number of other commands per second For example: PING, AUTH, INFO
Other commands latency Database Latency per other command The graph shows average, min, max and last values are also shown
Outgoing traffic Cluster, Node, Database Total outgoing traffic (in bytes/sec) from the database
Pending writes max CRDB Maximum number of writes queued
Pending writes min CRDB Minimum number of writes queued
RAM fragmentation Database, Shard Ratio between the used (allocated) memory and the actual physical RAM that is used.
Read misses/sec Database, Shard Number of read operations (per sec) on non-existing keys This metric is more relevant for caching use cases.
Reads latency Database Latency per read operation The graph shows average, min, max and last values are also shown
Reads/sec Database Number of total reads per second For example: GET
Total CPU usage Database, Shard Percent usage of the CPU
Total keys Database, Shard Total number of keys in the dataset (not including replication, even if replication enabled) Calculated as the sum of all keys of all master shards.
Used memory Database, Shard Total memory used by the database, including RAM, Flash (if enabled) and replication (if enabled) Note – used memory does not include:
1. The fragmentation overhead

2. The slave replication buffers at the masters

3. Memory used by Lua scripts

4. Copy On Write (COW) operation that can be triggered by:

- A full replication process is started

- A database snapshot process is started

- AOF rewrite process is started
Write misses/sec Database, Shard Number of write operations (per sec) on non-existing keys This metric is more relevant for caching use cases.
Writes latency Database Latency per write operation
Writes/sec Database Number of total writes per second For example: SET

Redis on Flash Metrics

Metric Components measured Description
% Values in RAM Database ROF, Shard ROF Percentage of Total key count, for which values are stored in RAM
Flash bytes/sec Cluster ROF, Node ROF, Database ROF, Shard ROF Read+write bytes per second on flash storage device
Flash fragmentation Database ROF, Shard ROF Ratio between the (logical) used flash memory and the actual physical flash that is used
Flash IOPS Cluster ROF, Node ROF Rate of I\O operations per second on flash storage device
Flash KV ops Node ROF Rate of operations on flash key values (read + write + del) per second
Flash ops/sec Database ROF, Shard ROF Rate of operations on flash key values (read + write + del) per second
Free flash Cluster ROF, Node ROF Free space on flash storage
RAM dataset overhead Database ROF, Shard ROF Percentage of the RAM limit that is used for anything other than values, such as key names, dictionaries and other overheads
RAM hit ratio Database ROF, Shard ROF Calculated as: requests_served_from_ram / total_requests;
Where:
1. requests_served_from_ram – refers to all requests processed values directly from RAM (that is without touching the Flash)
2. total_requests – refers to all requests processed by the database
RAM limit Database ROF RAM limit in bytes
RAM usage Database ROF Percentage of the RAM limit usage, calculated as: used_ram / ram_limit
RAM:Flash access ratio Database ROF, Shard ROF Ratio between logical redis key value operations, and actual flash key value operations (regardless of what triggered these operations, that is including ram eviction and other background tasks)
Used Flash Database ROF, Shard ROF Total RAM used to store values in Flash
Used RAM Database ROF, Shard ROF Total size of data stored in RAM, including keys, values, overheads and including replication, if enabled
Values in Flash Database ROF, Shard ROF Number of keys with values stored in Flash, not including replication
Values in RAM Database ROF, Shard ROF Number of keys with values stored in RAM, not including replication
What we can calculate and what we should know from the above
Redis on Flash average key size (+ overhead) Redis on Flash keeps all the keys and their overheads in RAM. Use the following steps to calculate the average size of a single key (including its overhead):
1. total_keys_size = non_values_ram_overhead * used_ram
2. avg_key_size = total_keys_size / (total_keys * 2)
Redis on Flash average value size, when the value is in RAM Use following steps to calculate the average size of a value in RAM:
total_size_of_values_in_ram = (1 – non_values_ram_overhead) * used_ram avg_value_size_in_ram = total_szie_of_values_in_ram / (values_in_ram * 2)
Redis on Flash average value size, when the value is in Flash This is calculated as: used_flash / values_in_flash
Note – Values in Flash are serialized and will always be smaller than in RAM
In Redis on Flash how come:
value_in_ram + value_in_flash > total_keys
Calculated as: used_flash / flash_limit