# 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.0.8 ## 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 (ZBXNEXT-5428-4.3). Test availability: `zabbix_get -s redis-master -k redis.ping` ### 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| |----|-----------|----|-----------------------| |Redis: Get info||Zabbix agent|redis.info["{$REDIS.CONN.URI}"]| |Redis: Get config||Zabbix agent|redis.config["{$REDIS.CONN.URI}"]

**Preprocessing**

Discard unchanged with heartbeat: `1h`

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

**Preprocessing**

Discard unchanged with heartbeat: `10m`

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

**Preprocessing**

Change per second

| |Redis: Get Clients info||Dependent item|redis.clients.info_raw

**Preprocessing**

JSON Path: `$.Clients`
⛔️Custom on fail: Discard value

| |Redis: Get CPU info||Dependent item|redis.cpu.info_raw

**Preprocessing**

JSON Path: `$.CPU`
⛔️Custom on fail: Discard value

| |Redis: Get Keyspace info||Dependent item|redis.keyspace.info_raw

**Preprocessing**

JSON Path: `$.Keyspace`
⛔️Custom on fail: Discard value

| |Redis: Get Memory info||Dependent item|redis.memory.info_raw

**Preprocessing**

JSON Path: `$.Memory`
⛔️Custom on fail: Discard value

| |Redis: Get Persistence info||Dependent item|redis.persistence.info_raw

**Preprocessing**

JSON Path: `$.Persistence`
⛔️Custom on fail: Discard value

| |Redis: Get Replication info||Dependent item|redis.replication.info_raw

**Preprocessing**

JSON Path: `$.Replication`
⛔️Custom on fail: Discard value

| |Redis: Get Server info||Dependent item|redis.server.info_raw

**Preprocessing**

JSON Path: `$.Server`
⛔️Custom on fail: Discard value

| |Redis: Get Stats info||Dependent item|redis.stats.info_raw

**Preprocessing**

JSON Path: `$.Stats`
⛔️Custom on fail: Discard value

| |Redis: CPU sys|

System CPU consumed by the Redis server

|Dependent item|redis.cpu.sys

**Preprocessing**

JSON Path: `$.used_cpu_sys`

| |Redis: CPU sys children|

System CPU consumed by the background processes

|Dependent item|redis.cpu.sys_children

**Preprocessing**

JSON Path: `$.used_cpu_sys_children`

| |Redis: CPU user|

User CPU consumed by the Redis server

|Dependent item|redis.cpu.user

**Preprocessing**

JSON Path: `$.used_cpu_user`

| |Redis: CPU user children|

User CPU consumed by the background processes

|Dependent item|redis.cpu.user_children

**Preprocessing**

JSON Path: `$.used_cpu_user_children`

| |Redis: Blocked clients|

The number of connections waiting on a blocking call

|Dependent item|redis.clients.blocked

**Preprocessing**

JSON Path: `$.blocked_clients`

| |Redis: 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.`

| |Redis: 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.`

| |Redis: Connected clients|

The number of connected clients

|Dependent item|redis.clients.connected

**Preprocessing**

JSON Path: `$.connected_clients`

| |Redis: Cluster enabled|

Indicate Redis cluster is enabled

|Dependent item|redis.cluster.enabled

**Preprocessing**

JSON Path: `$.Cluster.cluster_enabled`

| |Redis: Memory used|

Total number of bytes allocated by Redis using its allocator

|Dependent item|redis.memory.used_memory

**Preprocessing**

JSON Path: `$.used_memory`

| |Redis: Memory used Lua|

Amount of memory used by the Lua engine

|Dependent item|redis.memory.used_memory_lua

**Preprocessing**

JSON Path: `$.used_memory_lua`

| |Redis: Memory used peak|

Peak memory consumed by Redis (in bytes)

|Dependent item|redis.memory.used_memory_peak

**Preprocessing**

JSON Path: `$.used_memory_peak`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: AOF enabled|

Flag indicating AOF logging is activated

|Dependent item|redis.persistence.aof_enabled

**Preprocessing**

JSON Path: `$.aof_enabled`

| |Redis: 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

| |Redis: 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`

| |Redis: 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

| |Redis: AOF rewrite in progress|

Flag indicating a AOF rewrite operation is on-going

|Dependent item|redis.persistence.aof_rewrite_in_progress

**Preprocessing**

JSON Path: `$.aof_rewrite_in_progress`

| |Redis: 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`

| |Redis: Dump loading|

Flag indicating if the load of a dump file is on-going

|Dependent item|redis.persistence.loading

**Preprocessing**

JSON Path: `$.loading`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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

| |Redis: 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`

| |Redis: 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`

| |Redis: Connected slaves|

Number of connected slaves

|Dependent item|redis.replication.connected_slaves

**Preprocessing**

JSON Path: `$.connected_slaves`

| |Redis: Replication backlog active|

Flag indicating replication backlog is active

|Dependent item|redis.replication.repl_backlog_active

**Preprocessing**

JSON Path: `$.repl_backlog_active`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: Master replication offset|

Replication offset reported by the master

|Dependent item|redis.replication.master_repl_offset

**Preprocessing**

JSON Path: `$.master_repl_offset`

| |Redis: Process id|

PID of the server process

|Dependent item|redis.server.process_id

**Preprocessing**

JSON Path: `$.process_id`
Discard unchanged with heartbeat: `1d`

| |Redis: 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: Redis version|

Version of the Redis server

|Dependent item|redis.server.redis_version

**Preprocessing**

JSON Path: `$.redis_version`
Discard unchanged with heartbeat: `1d`

| |Redis: TCP port|

TCP/IP listen port

|Dependent item|redis.server.tcp_port

**Preprocessing**

JSON Path: `$.tcp_port`
Discard unchanged with heartbeat: `1d`

| |Redis: Uptime|

Number of seconds since Redis server start

|Dependent item|redis.server.uptime

**Preprocessing**

JSON Path: `$.uptime_in_seconds`

| |Redis: Evicted keys|

Number of evicted keys due to maxmemory limit

|Dependent item|redis.stats.evicted_keys

**Preprocessing**

JSON Path: `$.evicted_keys`

| |Redis: Expired keys|

Total number of key expiration events

|Dependent item|redis.stats.expired_keys

**Preprocessing**

JSON Path: `$.expired_keys`

| |Redis: 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`

| |Redis: Instantaneous operations per sec|

Number of commands processed per second

|Dependent item|redis.stats.instantaneous_ops.rate

**Preprocessing**

JSON Path: `$.instantaneous_ops_per_sec`

| |Redis: 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`

| |Redis: Keyspace hits|

Number of successful lookup of keys in the main dictionary

|Dependent item|redis.stats.keyspace_hits

**Preprocessing**

JSON Path: `$.keyspace_hits`

| |Redis: Keyspace misses|

Number of failed lookup of keys in the main dictionary

|Dependent item|redis.stats.keyspace_misses

**Preprocessing**

JSON Path: `$.keyspace_misses`

| |Redis: 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`

| |Redis: Migrate cached sockets|

The number of sockets open for MIGRATE purposes

|Dependent item|redis.stats.migrate_cached_sockets

**Preprocessing**

JSON Path: `$.migrate_cached_sockets`

| |Redis: Pubsub channels|

Global number of pub/sub channels with client subscriptions

|Dependent item|redis.stats.pubsub_channels

**Preprocessing**

JSON Path: `$.pubsub_channels`

| |Redis: Pubsub patterns|

Global number of pub/sub pattern with client subscriptions

|Dependent item|redis.stats.pubsub_patterns

**Preprocessing**

JSON Path: `$.pubsub_patterns`

| |Redis: Rejected connections|

Number of connections rejected because of maxclients limit

|Dependent item|redis.stats.rejected_connections

**Preprocessing**

JSON Path: `$.rejected_connections`

| |Redis: Sync full|

The number of full resyncs with replicas

|Dependent item|redis.stats.sync_full

**Preprocessing**

JSON Path: `$.sync_full`

| |Redis: Sync partial err|

The number of denied partial resync requests

|Dependent item|redis.stats.sync_partial_err

**Preprocessing**

JSON Path: `$.sync_partial_err`

| |Redis: Sync partial ok|

The number of accepted partial resync requests

|Dependent item|redis.stats.sync_partial_ok

**Preprocessing**

JSON Path: `$.sync_partial_ok`

| |Redis: Total commands processed|

Total number of commands processed by the server

|Dependent item|redis.stats.total_commands_processed

**Preprocessing**

JSON Path: `$.total_commands_processed`

| |Redis: Total connections received|

Total number of connections accepted by the server

|Dependent item|redis.stats.total_connections_received

**Preprocessing**

JSON Path: `$.total_connections_received`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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.

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: `$.Keyspace["{#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| |----|-----------|----|-----------------------| |Redis: AOF current size{#SINGLETON}|

AOF current file size

|Dependent item|redis.persistence.aof_current_size[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.aof_current_size`

| |Redis: 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`

| |Redis: 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`

| |Redis: AOF buffer length{#SINGLETON}|

Size of the AOF buffer

|Dependent item|redis.persistence.aof_buffer_length[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.aof_buffer_length`

| |Redis: 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

| |Redis: 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`

| |Redis: 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| |----|-----------|----|-----------------------| |Redis: 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`

| |Redis: Master port{#SINGLETON}|

Master listening TCP port

|Dependent item|redis.replication.master_port[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.master_port`
Discard unchanged with heartbeat: `1d`

| |Redis: 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

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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| |----|-----------|----|-----------------------| |Redis: Number of running processes||Zabbix agent|proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"]| |Redis: Memory usage (rss)|

Resident set size memory used by process in bytes.

|Zabbix agent|proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,rss]| |Redis: Memory usage (vsize)|

Virtual memory size used by process in bytes.

|Zabbix agent|proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,vsize]| |Redis: 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| |----|-----------|----|-----------------------| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: Max memory{#SINGLETON}|

Maximum amount of memory allocated to the Redisdb system

|Dependent item|redis.memory.maxmemory[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.maxmemory`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

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

**Preprocessing**

JSON Path: `$.expired_stale_perc`

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

**Preprocessing**

JSON Path: `$.expired_time_cap_reached_count`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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`

| |Redis: 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| |----|-----------|----|-----------------------| |Redis: Allocator active{#SINGLETON}||Dependent item|redis.memory.allocator_active[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.allocator_active`

| |Redis: Allocator allocated{#SINGLETON}||Dependent item|redis.memory.allocator_allocated[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.allocator_allocated`

| |Redis: Allocator resident{#SINGLETON}||Dependent item|redis.memory.allocator_resident[{#SINGLETON}]

**Preprocessing**

JSON Path: `$.allocator_resident`

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

**Preprocessing**

JSON Path: `$.used_memory_scripts`

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

**Preprocessing**

JSON Path: `$.number_of_cached_scripts`

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

**Preprocessing**

JSON Path: `$.allocator_frag_bytes`

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

**Preprocessing**

JSON Path: `$.allocator_frag_ratio`

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

**Preprocessing**

JSON Path: `$.allocator_rss_bytes`

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

**Preprocessing**

JSON Path: `$.allocator_rss_ratio`

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

**Preprocessing**

JSON Path: `$.rss_overhead_bytes`

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

**Preprocessing**

JSON Path: `$.rss_overhead_ratio`

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

**Preprocessing**

JSON Path: `$.mem_fragmentation_bytes`

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

**Preprocessing**

JSON Path: `$.mem_not_counted_for_evict`

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

**Preprocessing**

JSON Path: `$.mem_replication_backlog`

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

**Preprocessing**

JSON Path: `$.mem_clients_normal`

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

**Preprocessing**

JSON Path: `$.mem_clients_slaves`

| |Redis: 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)