
# Redis by Zabbix agent 2

## Overview

This template is designed for the effortless deployment of Redis monitoring by Zabbix via Zabbix agent 2 and doesn't require any external scripts.

## Requirements

Zabbix version: 7.0 and higher.

## Tested versions

This template has been tested on:
- Redis, version 3.0.6, 4.0.14, 5.0.6, 7.2.4

## Configuration

> Zabbix should be configured according to the instructions in the [Templates out of the box](https://www.zabbix.com/documentation/7.0/manual/config/templates_out_of_the_box) section.

## Setup

Setup and configure zabbix-agent2 compiled with the Redis monitoring plugin.

Redis' default user should have permissions to run CONFIG, INFO, PING, CLIENT and SLOWLOG commands.

Or default user ACL should have @admin, @slow, @dangerous, @fast and @connection categories.

Test availability: `zabbix_get -s 127.0.0.1 -k redis.ping[tcp://127.0.0.1:6379]`

### Macros used

|Name|Description|Default|
|----|-----------|-------|
|{$REDIS.CONN.URI}|
Connection string in the URI format (password is not used). This param overwrites a value configured in the "Server" option of the configuration file (if it's set), otherwise, the plugin's default value is used: "tcp://localhost:6379"
|`tcp://localhost:6379`|
|{$REDIS.PROCESS_NAME}|
Redis server process name
|`redis-server`|
|{$REDIS.LLD.PROCESS_NAME}|
Redis server process name for LLD
|`redis-server`|
|{$REDIS.LLD.FILTER.DB.MATCHES}|
Filter of discoverable databases
|`.*`|
|{$REDIS.LLD.FILTER.DB.NOT_MATCHES}|
Filter to exclude discovered databases
|`CHANGE_IF_NEEDED`|
|{$REDIS.REPL.LAG.MAX.WARN}|
Maximum replication lag in seconds
|`30s`|
|{$REDIS.SLOWLOG.COUNT.MAX.WARN}|
Maximum number of slowlog entries per second
|`1`|
|{$REDIS.CLIENTS.PRC.MAX.WARN}|
Maximum percentage of connected clients
|`80`|
|{$REDIS.MEM.PUSED.MAX.WARN}|
Maximum percentage of memory used
|`90`|
|{$REDIS.MEM.FRAG_RATIO.MAX.WARN}|
Maximum memory fragmentation ratio
|`1.5`|

### Items

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Get info||Zabbix agent|redis.info["{$REDIS.CONN.URI}"]|
|Get config||Zabbix agent|redis.config["{$REDIS.CONN.URI}"]
**Preprocessing**

- 
Discard unchanged with heartbeat: `1h`

|
|Ping||Zabbix agent|redis.ping["{$REDIS.CONN.URI}"]
**Preprocessing**

- 
Discard unchanged with heartbeat: `10m`

|
|Slowlog entries per second||Zabbix agent|redis.slowlog.count["{$REDIS.CONN.URI}"]
**Preprocessing**

- Change per second
|
|Get Clients info||Dependent item|redis.clients.info_raw
**Preprocessing**

- 
JSON Path: `$.Clients`

⛔️Custom on fail: Discard value

|
|Get CPU info||Dependent item|redis.cpu.info_raw
**Preprocessing**

- 
JSON Path: `$.CPU`

⛔️Custom on fail: Discard value

|
|Get Keyspace info||Dependent item|redis.keyspace.info_raw
**Preprocessing**

- 
JSON Path: `$.Keyspace`

⛔️Custom on fail: Discard value

|
|Get Memory info||Dependent item|redis.memory.info_raw
**Preprocessing**

- 
JSON Path: `$.Memory`

⛔️Custom on fail: Discard value

|
|Get Persistence info||Dependent item|redis.persistence.info_raw
**Preprocessing**

- 
JSON Path: `$.Persistence`

⛔️Custom on fail: Discard value

|
|Get Replication info||Dependent item|redis.replication.info_raw
**Preprocessing**

- 
JSON Path: `$.Replication`

⛔️Custom on fail: Discard value

|
|Get Server info||Dependent item|redis.server.info_raw
**Preprocessing**

- 
JSON Path: `$.Server`

⛔️Custom on fail: Discard value

|
|Get Stats info||Dependent item|redis.stats.info_raw
**Preprocessing**

- 
JSON Path: `$.Stats`

⛔️Custom on fail: Discard value

|
|CPU sys|
System CPU consumed by the Redis server
|Dependent item|redis.cpu.sys
**Preprocessing**

- 
JSON Path: `$.used_cpu_sys`

|
|CPU sys children|
System CPU consumed by the background processes
|Dependent item|redis.cpu.sys_children
**Preprocessing**

- 
JSON Path: `$.used_cpu_sys_children`

|
|CPU user|
User CPU consumed by the Redis server
|Dependent item|redis.cpu.user
**Preprocessing**

- 
JSON Path: `$.used_cpu_user`

|
|CPU user children|
User CPU consumed by the background processes
|Dependent item|redis.cpu.user_children
**Preprocessing**

- 
JSON Path: `$.used_cpu_user_children`

|
|Blocked clients|
The number of connections waiting on a blocking call
|Dependent item|redis.clients.blocked
**Preprocessing**

- 
JSON Path: `$.blocked_clients`

|
|Max input buffer|
The biggest input buffer among current client connections
|Dependent item|redis.clients.max_input_buffer
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|
|Max output buffer|
The biggest output buffer among current client connections
|Dependent item|redis.clients.max_output_buffer
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|
|Connected clients|
The number of connected clients
|Dependent item|redis.clients.connected
**Preprocessing**

- 
JSON Path: `$.connected_clients`

|
|Cluster enabled|
Indicate Redis cluster is enabled
|Dependent item|redis.cluster.enabled
**Preprocessing**

- 
JSON Path: `$.Cluster.cluster_enabled`

|
|Memory used|
Total number of bytes allocated by Redis using its allocator
|Dependent item|redis.memory.used_memory
**Preprocessing**

- 
JSON Path: `$.used_memory`

|
|Memory used Lua|
Amount of memory used by the Lua engine
|Dependent item|redis.memory.used_memory_lua
**Preprocessing**

- 
JSON Path: `$.used_memory_lua`

|
|Memory used peak|
Peak memory consumed by Redis (in bytes)
|Dependent item|redis.memory.used_memory_peak
**Preprocessing**

- 
JSON Path: `$.used_memory_peak`

|
|Memory used RSS|
Number of bytes that Redis allocated as seen by the operating system
|Dependent item|redis.memory.used_memory_rss
**Preprocessing**

- 
JSON Path: `$.used_memory_rss`

|
|Memory fragmentation ratio|
This ratio is an indication of memory mapping efficiency:

  - Value over 1.0 indicate that memory fragmentation is very likely. Consider restarting the Redis server so the operating system can recover fragmented memory, especially with a ratio over 1.5.

  - Value under 1.0 indicate that Redis likely has insufficient memory available. Consider optimizing memory usage or adding more RAM.

Note: If your peak memory usage is much higher than your current memory usage, the memory fragmentation ratio may be unreliable.

https://redis.io/topics/memory-optimization
|Dependent item|redis.memory.fragmentation_ratio
**Preprocessing**

- 
JSON Path: `$.mem_fragmentation_ratio`

|
|AOF current rewrite time sec|
Duration of the on-going AOF rewrite operation if any
|Dependent item|redis.persistence.aof_current_rewrite_time_sec
**Preprocessing**

- 
JSON Path: `$.aof_current_rewrite_time_sec`

|
|AOF enabled|
Flag indicating AOF logging is activated
|Dependent item|redis.persistence.aof_enabled
**Preprocessing**

- 
JSON Path: `$.aof_enabled`

|
|AOF last bgrewrite status|
Status of the last AOF rewrite operation
|Dependent item|redis.persistence.aof_last_bgrewrite_status
**Preprocessing**

- 
JSON Path: `$.aof_last_bgrewrite_status`

- Boolean to decimal
|
|AOF last rewrite time sec|
Duration of the last AOF rewrite
|Dependent item|redis.persistence.aof_last_rewrite_time_sec
**Preprocessing**

- 
JSON Path: `$.aof_last_rewrite_time_sec`

|
|AOF last write status|
Status of the last write operation to the AOF
|Dependent item|redis.persistence.aof_last_write_status
**Preprocessing**

- 
JSON Path: `$.aof_last_write_status`

- Boolean to decimal
|
|AOF rewrite in progress|
Flag indicating an AOF rewrite operation is on-going
|Dependent item|redis.persistence.aof_rewrite_in_progress
**Preprocessing**

- 
JSON Path: `$.aof_rewrite_in_progress`

|
|AOF rewrite scheduled|
Flag indicating an AOF rewrite operation will be scheduled once the on-going RDB save is complete
|Dependent item|redis.persistence.aof_rewrite_scheduled
**Preprocessing**

- 
JSON Path: `$.aof_rewrite_scheduled`

|
|Dump loading|
Flag indicating if the load of a dump file is on-going
|Dependent item|redis.persistence.loading
**Preprocessing**

- 
JSON Path: `$.loading`

|
|RDB bgsave in progress|
"1" if bgsave is in progress and "0" otherwise
|Dependent item|redis.persistence.rdb_bgsave_in_progress
**Preprocessing**

- 
JSON Path: `$.rdb_bgsave_in_progress`

|
|RDB changes since last save|
Number of changes since the last background save
|Dependent item|redis.persistence.rdb_changes_since_last_save
**Preprocessing**

- 
JSON Path: `$.rdb_changes_since_last_save`

|
|RDB current bgsave time sec|
Duration of the on-going RDB save operation if any
|Dependent item|redis.persistence.rdb_current_bgsave_time_sec
**Preprocessing**

- 
JSON Path: `$.rdb_current_bgsave_time_sec`

|
|RDB last bgsave status|
Status of the last RDB save operation
|Dependent item|redis.persistence.rdb_last_bgsave_status
**Preprocessing**

- 
JSON Path: `$.rdb_last_bgsave_status`

- Boolean to decimal
|
|RDB last bgsave time sec|
Duration of the last bg_save operation
|Dependent item|redis.persistence.rdb_last_bgsave_time_sec
**Preprocessing**

- 
JSON Path: `$.rdb_last_bgsave_time_sec`

|
|RDB last save time|
Epoch-based timestamp of last successful RDB save
|Dependent item|redis.persistence.rdb_last_save_time
**Preprocessing**

- 
JSON Path: `$.rdb_last_save_time`

|
|Connected slaves|
Number of connected slaves
|Dependent item|redis.replication.connected_slaves
**Preprocessing**

- 
JSON Path: `$.connected_slaves`

|
|Replication backlog active|
Flag indicating replication backlog is active
|Dependent item|redis.replication.repl_backlog_active
**Preprocessing**

- 
JSON Path: `$.repl_backlog_active`

|
|Replication backlog first byte offset|
The master offset of the replication backlog buffer
|Dependent item|redis.replication.repl_backlog_first_byte_offset
**Preprocessing**

- 
JSON Path: `$.repl_backlog_first_byte_offset`

|
|Replication backlog history length|
Amount of data in the backlog sync buffer
|Dependent item|redis.replication.repl_backlog_histlen
**Preprocessing**

- 
JSON Path: `$.repl_backlog_histlen`

|
|Replication backlog size|
Total size in bytes of the replication backlog buffer
|Dependent item|redis.replication.repl_backlog_size
**Preprocessing**

- 
JSON Path: `$.repl_backlog_size`

|
|Replication role|
Value is "master" if the instance is replica of no one, or "slave" if the instance is a replica of some master instance. Note that a replica can be master of another replica (chained replication).
|Dependent item|redis.replication.role
**Preprocessing**

- 
JSON Path: `$.role`

- 
Discard unchanged with heartbeat: `1d`

|
|Master replication offset|
Replication offset reported by the master
|Dependent item|redis.replication.master_repl_offset
**Preprocessing**

- 
JSON Path: `$.master_repl_offset`

|
|Process id|
PID of the server process
|Dependent item|redis.server.process_id
**Preprocessing**

- 
JSON Path: `$.process_id`

- 
Discard unchanged with heartbeat: `1d`

|
|Redis mode|
The server's mode ("standalone", "sentinel" or "cluster")
|Dependent item|redis.server.redis_mode
**Preprocessing**

- 
JSON Path: `$.redis_mode`

- 
Discard unchanged with heartbeat: `1d`

|
|Redis version|
Version of the Redis server
|Dependent item|redis.server.redis_version
**Preprocessing**

- 
JSON Path: `$.redis_version`

- 
Discard unchanged with heartbeat: `1d`

|
|TCP port|
TCP/IP listen port
|Dependent item|redis.server.tcp_port
**Preprocessing**

- 
JSON Path: `$.tcp_port`

- 
Discard unchanged with heartbeat: `1d`

|
|Uptime|
Number of seconds since Redis server start
|Dependent item|redis.server.uptime
**Preprocessing**

- 
JSON Path: `$.uptime_in_seconds`

|
|Evicted keys|
Number of evicted keys due to maxmemory limit
|Dependent item|redis.stats.evicted_keys
**Preprocessing**

- 
JSON Path: `$.evicted_keys`

|
|Expired keys|
Total number of key expiration events
|Dependent item|redis.stats.expired_keys
**Preprocessing**

- 
JSON Path: `$.expired_keys`

|
|Instantaneous input bytes per second|
The network's read rate per second in KB/sec
|Dependent item|redis.stats.instantaneous_input.rate
**Preprocessing**

- 
JSON Path: `$.instantaneous_input_kbps`

- 
Custom multiplier: `1024`

|
|Instantaneous operations per sec|
Number of commands processed per second
|Dependent item|redis.stats.instantaneous_ops.rate
**Preprocessing**

- 
JSON Path: `$.instantaneous_ops_per_sec`

|
|Instantaneous output bytes per second|
The network's write rate per second in KB/sec
|Dependent item|redis.stats.instantaneous_output.rate
**Preprocessing**

- 
JSON Path: `$.instantaneous_output_kbps`

- 
Custom multiplier: `1024`

|
|Keyspace hits|
Number of successful lookup of keys in the main dictionary
|Dependent item|redis.stats.keyspace_hits
**Preprocessing**

- 
JSON Path: `$.keyspace_hits`

|
|Keyspace misses|
Number of failed lookup of keys in the main dictionary
|Dependent item|redis.stats.keyspace_misses
**Preprocessing**

- 
JSON Path: `$.keyspace_misses`

|
|Latest fork usec|
Duration of the latest fork operation in microseconds
|Dependent item|redis.stats.latest_fork_usec
**Preprocessing**

- 
JSON Path: `$.latest_fork_usec`

- 
Custom multiplier: `1e-05`

|
|Migrate cached sockets|
The number of sockets open for MIGRATE purposes
|Dependent item|redis.stats.migrate_cached_sockets
**Preprocessing**

- 
JSON Path: `$.migrate_cached_sockets`

|
|Pubsub channels|
Global number of pub/sub channels with client subscriptions
|Dependent item|redis.stats.pubsub_channels
**Preprocessing**

- 
JSON Path: `$.pubsub_channels`

|
|Pubsub patterns|
Global number of pub/sub pattern with client subscriptions
|Dependent item|redis.stats.pubsub_patterns
**Preprocessing**

- 
JSON Path: `$.pubsub_patterns`

|
|Rejected connections|
Number of connections rejected because of maxclients limit
|Dependent item|redis.stats.rejected_connections
**Preprocessing**

- 
JSON Path: `$.rejected_connections`

|
|Sync full|
The number of full resyncs with replicas
|Dependent item|redis.stats.sync_full
**Preprocessing**

- 
JSON Path: `$.sync_full`

|
|Sync partial err|
The number of denied partial resync requests
|Dependent item|redis.stats.sync_partial_err
**Preprocessing**

- 
JSON Path: `$.sync_partial_err`

|
|Sync partial ok|
The number of accepted partial resync requests
|Dependent item|redis.stats.sync_partial_ok
**Preprocessing**

- 
JSON Path: `$.sync_partial_ok`

|
|Total commands processed|
Total number of commands processed by the server
|Dependent item|redis.stats.total_commands_processed
**Preprocessing**

- 
JSON Path: `$.total_commands_processed`

|
|Total connections received|
Total number of connections accepted by the server
|Dependent item|redis.stats.total_connections_received
**Preprocessing**

- 
JSON Path: `$.total_connections_received`

|
|Total net input bytes|
The total number of bytes read from the network
|Dependent item|redis.stats.total_net_input_bytes
**Preprocessing**

- 
JSON Path: `$.total_net_input_bytes`

|
|Total net output bytes|
The total number of bytes written to the network
|Dependent item|redis.stats.total_net_output_bytes
**Preprocessing**

- 
JSON Path: `$.total_net_output_bytes`

|
|Max clients|
Max number of connected clients at the same time.

Once the limit is reached Redis will close all the new connections sending an error "max number of clients reached".
|Dependent item|redis.config.maxclients
**Preprocessing**

- 
JSON Path: `$.maxclients`

- 
Discard unchanged with heartbeat: `30m`

|

### Triggers

|Name|Description|Expression|Severity|Dependencies and additional info|
|----|-----------|----------|--------|--------------------------------|
|Redis: Failed to fetch info data|
Zabbix has not received any data for items for the last 30 minutes.
|`nodata(/Redis by Zabbix agent 2/redis.info["{$REDIS.CONN.URI}"],30m)=1`|Warning|**Manual close**: Yes
**Depends on**:

- Redis: Service is down
|
|Redis: Configuration has changed|
Redis configuration has changed. Acknowledge to close the problem manually.
|`last(/Redis by Zabbix agent 2/redis.config["{$REDIS.CONN.URI}"],#1)<>last(/Redis by Zabbix agent 2/redis.config["{$REDIS.CONN.URI}"],#2) and length(last(/Redis by Zabbix agent 2/redis.config["{$REDIS.CONN.URI}"]))>0`|Info|**Manual close**: Yes|
|Redis: Service is down||`last(/Redis by Zabbix agent 2/redis.ping["{$REDIS.CONN.URI}"])=0`|Average|**Manual close**: Yes|
|Redis: Too many entries in the slowlog||`min(/Redis by Zabbix agent 2/redis.slowlog.count["{$REDIS.CONN.URI}"],5m)>{$REDIS.SLOWLOG.COUNT.MAX.WARN}`|Info||
|Redis: Total number of connected clients is too high|
When the number of clients reaches the value of the "maxclients" parameter, new connections will be rejected.

https://redis.io/topics/clients#maximum-number-of-clients
|`min(/Redis by Zabbix agent 2/redis.clients.connected,5m)/last(/Redis by Zabbix agent 2/redis.config.maxclients)*100>{$REDIS.CLIENTS.PRC.MAX.WARN}`|Warning||
|Redis: Memory fragmentation ratio is too high|
This ratio is an indication of memory mapping efficiency:
  - Value over 1.0 indicate that memory fragmentation is very likely. Consider restarting the Redis server so the operating system can recover fragmented memory, especially with a ratio over 1.5.
  - Value under 1.0 indicate that Redis likely has insufficient memory available. Consider optimizing memory usage or adding more RAM.

Note: If your peak memory usage is much higher than your current memory usage, the memory fragmentation ratio may be unreliable.

https://redis.io/topics/memory-optimization
|`min(/Redis by Zabbix agent 2/redis.memory.fragmentation_ratio,15m)>{$REDIS.MEM.FRAG_RATIO.MAX.WARN}`|Warning||
|Redis: Last AOF write operation failed|
Detailed information about persistence: https://redis.io/topics/persistence
|`last(/Redis by Zabbix agent 2/redis.persistence.aof_last_write_status)=0`|Warning||
|Redis: Last RDB save operation failed|
Detailed information about persistence: https://redis.io/topics/persistence
|`last(/Redis by Zabbix agent 2/redis.persistence.rdb_last_bgsave_status)=0`|Warning||
|Redis: Number of slaves has changed|
Redis number of slaves has changed. Acknowledge to close the problem manually.
|`last(/Redis by Zabbix agent 2/redis.replication.connected_slaves,#1)<>last(/Redis by Zabbix agent 2/redis.replication.connected_slaves,#2)`|Info|**Manual close**: Yes|
|Redis: Replication role has changed|
Redis replication role has changed. Acknowledge to close the problem manually.
|`last(/Redis by Zabbix agent 2/redis.replication.role,#1)<>last(/Redis by Zabbix agent 2/redis.replication.role,#2) and length(last(/Redis by Zabbix agent 2/redis.replication.role))>0`|Warning|**Manual close**: Yes|
|Redis: Version has changed|
The Redis version has changed. Acknowledge to close the problem manually.
|`last(/Redis by Zabbix agent 2/redis.server.redis_version,#1)<>last(/Redis by Zabbix agent 2/redis.server.redis_version,#2) and length(last(/Redis by Zabbix agent 2/redis.server.redis_version))>0`|Info|**Manual close**: Yes|
|Redis: Host has been restarted|
The host uptime is less than 10 minutes.
|`last(/Redis by Zabbix agent 2/redis.server.uptime)<10m`|Info|**Manual close**: Yes|
|Redis: Connections are rejected|
The number of connections has reached the value of "maxclients".

https://redis.io/topics/clients
|`last(/Redis by Zabbix agent 2/redis.stats.rejected_connections)>0`|High||

### LLD rule Keyspace discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Keyspace discovery|
Individual keyspace metrics
|Dependent item|redis.keyspace.discovery
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Keyspace discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|DB {#DB}: Get Keyspace info|
The item gets information about keyspace of {#DB} database.
|Dependent item|redis.db.info_raw["{#DB}"]
**Preprocessing**

- 
JSON Path: `$['{#DB}']`

⛔️Custom on fail: Discard value

|
|DB {#DB}: Average TTL|
Average TTL
|Dependent item|redis.db.avg_ttl["{#DB}"]
**Preprocessing**

- 
JSON Path: `$.avg_ttl`

- 
Custom multiplier: `0.001`

|
|DB {#DB}: Expires|
Number of keys with an expiration
|Dependent item|redis.db.expires["{#DB}"]
**Preprocessing**

- 
JSON Path: `$.expires`

|
|DB {#DB}: Keys|
Total number of keys
|Dependent item|redis.db.keys["{#DB}"]
**Preprocessing**

- 
JSON Path: `$.keys`

|

### LLD rule AOF metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|AOF metrics discovery|
If AOF is activated, additional metrics will be added
|Dependent item|redis.persistence.aof.discovery
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for AOF metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|AOF current size{#SINGLETON}|
AOF current file size
|Dependent item|redis.persistence.aof_current_size[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_current_size`

|
|AOF base size{#SINGLETON}|
AOF file size on latest startup or rewrite
|Dependent item|redis.persistence.aof_base_size[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_base_size`

|
|AOF pending rewrite{#SINGLETON}|
Flag indicating an AOF rewrite operation will
|Dependent item|redis.persistence.aof_pending_rewrite[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_pending_rewrite`

|
|AOF buffer length{#SINGLETON}|
Size of the AOF buffer
|Dependent item|redis.persistence.aof_buffer_length[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_buffer_length`

|
|AOF rewrite buffer length{#SINGLETON}|
Size of the AOF rewrite buffer
|Dependent item|redis.persistence.aof_rewrite_buffer_length[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_rewrite_buffer_length`

⛔️Custom on fail: Discard value

|
|AOF pending background I/O fsync{#SINGLETON}|
Number of fsync pending jobs in background I/O queue
|Dependent item|redis.persistence.aof_pending_bio_fsync[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_pending_bio_fsync`

|
|AOF delayed fsync{#SINGLETON}|
Delayed fsync counter
|Dependent item|redis.persistence.aof_delayed_fsync[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_delayed_fsync`

|

### LLD rule Slave metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Slave metrics discovery|
If the instance is a replica, additional metrics are provided
|Dependent item|redis.replication.slave.discovery
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Slave metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Master host{#SINGLETON}|
Host or IP address of the master
|Dependent item|redis.replication.master_host[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.master_host`

- 
Discard unchanged with heartbeat: `1d`

|
|Master port{#SINGLETON}|
Master listening TCP port
|Dependent item|redis.replication.master_port[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.master_port`

- 
Discard unchanged with heartbeat: `1d`

|
|Master link status{#SINGLETON}|
Status of the link (up/down)
|Dependent item|redis.replication.master_link_status[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.master_link_status`

- Boolean to decimal
|
|Master last I/O seconds ago{#SINGLETON}|
Number of seconds since the last interaction with master
|Dependent item|redis.replication.master_last_io_seconds_ago[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.master_last_io_seconds_ago`

|
|Master sync in progress{#SINGLETON}|
Indicate the master is syncing to the replica
|Dependent item|redis.replication.master_sync_in_progress[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.master_sync_in_progress`

|
|Slave replication offset{#SINGLETON}|
The replication offset of the replica instance
|Dependent item|redis.replication.slave_repl_offset[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.slave_repl_offset`

|
|Slave priority{#SINGLETON}|
The priority of the instance as a candidate for failover
|Dependent item|redis.replication.slave_priority[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.slave_priority`

|
|Slave priority{#SINGLETON}|
Flag indicating if the replica is read-only
|Dependent item|redis.replication.slave_read_only[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.slave_read_only`

- 
Discard unchanged with heartbeat: `1d`

|

### Trigger prototypes for Slave metrics discovery

|Name|Description|Expression|Severity|Dependencies and additional info|
|----|-----------|----------|--------|--------------------------------|
|Redis: Replication lag with master is too high||`min(/Redis by Zabbix agent 2/redis.replication.master_last_io_seconds_ago[{#SINGLETON}],5m)>{$REDIS.REPL.LAG.MAX.WARN}`|Warning||

### LLD rule Replication metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Replication metrics discovery|
If the instance is the master and the slaves are connected, additional metrics are provided
|Dependent item|redis.replication.master.discovery
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Replication metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Redis slave {#SLAVE_IP}:{#SLAVE_PORT}: Replication lag in bytes|
Replication lag in bytes
|Dependent item|redis.replication.lag_bytes["{#SLAVE_IP}:{#SLAVE_PORT}"]
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### LLD rule Process metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Process metrics discovery|
Collect metrics by Zabbix agent if it exists
|Zabbix agent|proc.num["{$REDIS.LLD.PROCESS_NAME}"]
**Preprocessing**

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Process metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Number of running processes||Zabbix agent|proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"]|
|Memory usage (rss)|
Resident set size memory used by process in bytes.
|Zabbix agent|proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,rss]|
|Memory usage (vsize)|
Virtual memory size used by process in bytes.
|Zabbix agent|proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,vsize]|
|CPU utilization|
Process CPU utilization percentage.
|Zabbix agent|proc.cpu.util["{$REDIS.PROCESS_NAME}{#SINGLETON}"]|

### Trigger prototypes for Process metrics discovery

|Name|Description|Expression|Severity|Dependencies and additional info|
|----|-----------|----------|--------|--------------------------------|
|Redis: Process is not running||`last(/Redis by Zabbix agent 2/proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"])=0`|High||

### LLD rule Version 4+ metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Version 4+ metrics discovery|
Additional metrics for versions 4+
|Dependent item|redis.metrics.v4.discovery
**Preprocessing**

- 
JSON Path: `$.redis_version`

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Version 4+ metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Executable path{#SINGLETON}|
The path to the server's executable
|Dependent item|redis.server.executable[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.executable`

- 
Discard unchanged with heartbeat: `1d`

|
|Memory used peak %{#SINGLETON}|
The percentage of used_memory_peak out of used_memory
|Dependent item|redis.memory.used_memory_peak_perc[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_peak_perc`

- 
Regular expression: `(.+)% \1`

|
|Memory used overhead{#SINGLETON}|
The sum in bytes of all overheads that the server allocated for managing its internal data structures
|Dependent item|redis.memory.used_memory_overhead[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_overhead`

|
|Memory used startup{#SINGLETON}|
Initial amount of memory consumed by Redis at startup in bytes
|Dependent item|redis.memory.used_memory_startup[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_startup`

|
|Memory used dataset{#SINGLETON}|
The size in bytes of the dataset
|Dependent item|redis.memory.used_memory_dataset[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_dataset`

|
|Memory used dataset %{#SINGLETON}|
The percentage of used_memory_dataset out of the net memory usage (used_memory minus used_memory_startup)
|Dependent item|redis.memory.used_memory_dataset_perc[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_dataset_perc`

- 
Regular expression: `(.+)% \1`

|
|Total system memory{#SINGLETON}|
The total amount of memory that the Redis host has
|Dependent item|redis.memory.total_system_memory[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.total_system_memory`

|
|Max memory{#SINGLETON}|
Maximum amount of memory allocated to the Redisdb system
|Dependent item|redis.memory.maxmemory[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.maxmemory`

|
|Max memory policy{#SINGLETON}|
The value of the maxmemory-policy configuration directive
|Dependent item|redis.memory.maxmemory_policy[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.maxmemory_policy`

- 
Discard unchanged with heartbeat: `1d`

|
|Active defrag running{#SINGLETON}|
Flag indicating if active defragmentation is active
|Dependent item|redis.memory.active_defrag_running[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.active_defrag_running`

|
|Lazyfree pending objects{#SINGLETON}|
The number of objects waiting to be freed (as a result of calling UNLINK, or FLUSHDB and FLUSHALL with the ASYNC option)
|Dependent item|redis.memory.lazyfree_pending_objects[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.lazyfree_pending_objects`

|
|RDB last CoW size{#SINGLETON}|
The size in bytes of copy-on-write allocations during the last RDB save operation
|Dependent item|redis.persistence.rdb_last_cow_size[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.rdb_last_cow_size`

|
|AOF last CoW size{#SINGLETON}|
The size in bytes of copy-on-write allocations during the last AOF rewrite operation
|Dependent item|redis.persistence.aof_last_cow_size[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.aof_last_cow_size`

|
|Expired stale %{#SINGLETON}||Dependent item|redis.stats.expired_stale_perc[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.expired_stale_perc`

|
|Expired time cap reached count{#SINGLETON}||Dependent item|redis.stats.expired_time_cap_reached_count[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.expired_time_cap_reached_count`

|
|Slave expires tracked keys{#SINGLETON}|
The number of keys tracked for expiry purposes (applicable only to writable replicas)
|Dependent item|redis.stats.slave_expires_tracked_keys[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.slave_expires_tracked_keys`

|
|Active defrag hits{#SINGLETON}|
Number of value reallocations performed by active the defragmentation process
|Dependent item|redis.stats.active_defrag_hits[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.active_defrag_hits`

|
|Active defrag misses{#SINGLETON}|
Number of aborted value reallocations started by the active defragmentation process
|Dependent item|redis.stats.active_defrag_misses[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.active_defrag_misses`

|
|Active defrag key hits{#SINGLETON}|
Number of keys that were actively defragmented
|Dependent item|redis.stats.active_defrag_key_hits[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.active_defrag_key_hits`

|
|Active defrag key misses{#SINGLETON}|
Number of keys that were skipped by the active defragmentation process
|Dependent item|redis.stats.active_defrag_key_misses[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.active_defrag_key_misses`

|
|Replication second offset{#SINGLETON}|
Offset up to which replication IDs are accepted
|Dependent item|redis.replication.second_repl_offset[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.second_repl_offset`

|

### Trigger prototypes for Version 4+ metrics discovery

|Name|Description|Expression|Severity|Dependencies and additional info|
|----|-----------|----------|--------|--------------------------------|
|Redis: Memory usage is too high||`last(/Redis by Zabbix agent 2/redis.memory.used_memory)/min(/Redis by Zabbix agent 2/redis.memory.maxmemory[{#SINGLETON}],5m)*100>{$REDIS.MEM.PUSED.MAX.WARN}`|Warning||

### LLD rule Version 5+ metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Version 5+ metrics discovery|
Additional metrics for versions 5+
|Dependent item|redis.metrics.v5.discovery
**Preprocessing**

- 
JSON Path: `$.redis_version`

- 
JavaScript: `The text is too long. Please see the template.`

|

### Item prototypes for Version 5+ metrics discovery

|Name|Description|Type|Key and additional info|
|----|-----------|----|-----------------------|
|Allocator active{#SINGLETON}||Dependent item|redis.memory.allocator_active[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_active`

|
|Allocator allocated{#SINGLETON}||Dependent item|redis.memory.allocator_allocated[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_allocated`

|
|Allocator resident{#SINGLETON}||Dependent item|redis.memory.allocator_resident[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_resident`

|
|Memory used scripts{#SINGLETON}||Dependent item|redis.memory.used_memory_scripts[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.used_memory_scripts`

|
|Memory number of cached scripts{#SINGLETON}||Dependent item|redis.memory.number_of_cached_scripts[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.number_of_cached_scripts`

|
|Allocator fragmentation bytes{#SINGLETON}||Dependent item|redis.memory.allocator_frag_bytes[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_frag_bytes`

|
|Allocator fragmentation ratio{#SINGLETON}||Dependent item|redis.memory.allocator_frag_ratio[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_frag_ratio`

|
|Allocator RSS bytes{#SINGLETON}||Dependent item|redis.memory.allocator_rss_bytes[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_rss_bytes`

|
|Allocator RSS ratio{#SINGLETON}||Dependent item|redis.memory.allocator_rss_ratio[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.allocator_rss_ratio`

|
|Memory RSS overhead bytes{#SINGLETON}||Dependent item|redis.memory.rss_overhead_bytes[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.rss_overhead_bytes`

|
|Memory RSS overhead ratio{#SINGLETON}||Dependent item|redis.memory.rss_overhead_ratio[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.rss_overhead_ratio`

|
|Memory fragmentation bytes{#SINGLETON}||Dependent item|redis.memory.fragmentation_bytes[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_fragmentation_bytes`

|
|Memory not counted for evict{#SINGLETON}||Dependent item|redis.memory.not_counted_for_evict[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_not_counted_for_evict`

|
|Memory replication backlog{#SINGLETON}||Dependent item|redis.memory.replication_backlog[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_replication_backlog`

|
|Memory clients normal{#SINGLETON}||Dependent item|redis.memory.mem_clients_normal[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_clients_normal`

|
|Memory clients slaves{#SINGLETON}||Dependent item|redis.memory.mem_clients_slaves[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_clients_slaves`

|
|Memory AOF buffer{#SINGLETON}|
Size of the AOF buffer
|Dependent item|redis.memory.mem_aof_buffer[{#SINGLETON}]
**Preprocessing**

- 
JSON Path: `$.mem_aof_buffer`

|

## Feedback

Please report any issues with the template at [`https://support.zabbix.com`](https://support.zabbix.com)

You can also provide feedback, discuss the template, or ask for help at [`ZABBIX forums`](https://www.zabbix.com/forum/zabbix-suggestions-and-feedback)

