Redis by Zabbix agent 2

Macros used

Name	Value
{$REDIS.CLIENTS.PRC.MAX.WARN}	80
{$REDIS.CONN.URI}	tcp://localhost:6379
{$REDIS.LLD.FILTER.DB.MATCHES}	.*
{$REDIS.LLD.FILTER.DB.NOT_MATCHES}	CHANGE_IF_NEEDED
{$REDIS.LLD.PROCESS_NAME}	redis-server
{$REDIS.MEM.FRAG_RATIO.MAX.WARN}	1.5
{$REDIS.MEM.PUSED.MAX.WARN}	90
{$REDIS.PROCESS_NAME}	redis-server
{$REDIS.REPL.LAG.MAX.WARN}	30s
{$REDIS.SLOWLOG.COUNT.MAX.WARN}	1

Items collected

Name	Description	Type	Interval	Key and additional info
Redis: Blocked clients	The number of connections waiting on a blocking call	DEPENDENT	-	redis.clients.blocked
Redis: Connected clients	The number of connected clients	DEPENDENT	-	redis.clients.connected
Redis: Max input buffer	The biggest input buffer among current client connections	DEPENDENT	-	redis.clients.max_input_buffer
Redis: Max output buffer	The biggest output buffer among current client connections	DEPENDENT	-	redis.clients.max_output_buffer
Redis: Cluster enabled	Indicate Redis cluster is enabled	DEPENDENT	-	redis.cluster.enabled
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	-	redis.config.maxclients
Redis: Get config	-	-	-	redis.config["{$REDIS.CONN.URI}"]
Redis: CPU sys	System CPU consumed by the Redis server	DEPENDENT	-	redis.cpu.sys
Redis: CPU sys children	System CPU consumed by the background processes	DEPENDENT	-	redis.cpu.sys_children
Redis: CPU user	User CPU consumed by the Redis server	DEPENDENT	-	redis.cpu.user
Redis: CPU user children	User CPU consumed by the background processes	DEPENDENT	-	redis.cpu.user_children
Redis: Get info	-	-	-	redis.info["{$REDIS.CONN.URI}"]
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	-	redis.memory.fragmentation_ratio
Redis: Memory used	Total number of bytes allocated by Redis using its allocator	DEPENDENT	-	redis.memory.used_memory
Redis: Memory used Lua	Amount of memory used by the Lua engine	DEPENDENT	-	redis.memory.used_memory_lua
Redis: Memory used peak	Peak memory consumed by Redis (in bytes)	DEPENDENT	-	redis.memory.used_memory_peak
Redis: Memory used RSS	Number of bytes that Redis allocated as seen by the operating system	DEPENDENT	-	redis.memory.used_memory_rss
Redis: AOF current rewrite time sec	Duration of the on-going AOF rewrite operation if any	DEPENDENT	-	redis.persistence.aof_current_rewrite_time_sec
Redis: AOF enabled	Flag indicating AOF logging is activated	DEPENDENT	-	redis.persistence.aof_enabled
Redis: AOF last bgrewrite status	Status of the last AOF rewrite operation	DEPENDENT	-	redis.persistence.aof_last_bgrewrite_status
Redis: AOF last rewrite time sec	Duration of the last AOF rewrite	DEPENDENT	-	redis.persistence.aof_last_rewrite_time_sec
Redis: AOF last write status	Status of the last write operation to the AOF	DEPENDENT	-	redis.persistence.aof_last_write_status
Redis: AOF rewrite in progress	Flag indicating a AOF rewrite operation is on-going	DEPENDENT	-	redis.persistence.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	-	redis.persistence.aof_rewrite_scheduled
Redis: Dump loading	Flag indicating if the load of a dump file is on-going	DEPENDENT	-	redis.persistence.loading
Redis: RDB bgsave in progress	"1" if bgsave is in progress and "0" otherwise	DEPENDENT	-	redis.persistence.rdb_bgsave_in_progress
Redis: RDB changes since last save	Number of changes since the last background save	DEPENDENT	-	redis.persistence.rdb_changes_since_last_save
Redis: RDB current bgsave time sec	Duration of the on-going RDB save operation if any	DEPENDENT	-	redis.persistence.rdb_current_bgsave_time_sec
Redis: RDB last bgsave status	Status of the last RDB save operation	DEPENDENT	-	redis.persistence.rdb_last_bgsave_status
Redis: RDB last bgsave time sec	Duration of the last bg_save operation	DEPENDENT	-	redis.persistence.rdb_last_bgsave_time_sec
Redis: RDB last save time	Epoch-based timestamp of last successful RDB save	DEPENDENT	-	redis.persistence.rdb_last_save_time
Redis: Ping	-	-	-	redis.ping["{$REDIS.CONN.URI}"]
Redis: Connected slaves	Number of connected slaves	DEPENDENT	-	redis.replication.connected_slaves
Redis: Master replication offset	Replication offset reported by the master	DEPENDENT	-	redis.replication.master_repl_offset
Redis: Replication backlog active	Flag indicating replication backlog is active	DEPENDENT	-	redis.replication.repl_backlog_active
Redis: Replication backlog first byte offset	The master offset of the replication backlog buffer	DEPENDENT	-	redis.replication.repl_backlog_first_byte_offset
Redis: Replication backlog history length	Amount of data in the backlog sync buffer	DEPENDENT	-	redis.replication.repl_backlog_histlen
Redis: Replication backlog size	Total size in bytes of the replication backlog buffer	DEPENDENT	-	redis.replication.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	-	redis.replication.role
Redis: Process id	PID of the server process	DEPENDENT	-	redis.server.process_id
Redis: Redis mode	The server's mode ("standalone", "sentinel" or "cluster")	DEPENDENT	-	redis.server.redis_mode
Redis: Redis version	Version of the Redis server	DEPENDENT	-	redis.server.redis_version
Redis: TCP port	TCP/IP listen port	DEPENDENT	-	redis.server.tcp_port
Redis: Uptime	Number of seconds since Redis server start	DEPENDENT	-	redis.server.uptime
Redis: Slowlog entries per second	-	-	-	redis.slowlog.count["{$REDIS.CONN.URI}"]
Redis: Evicted keys	Number of evicted keys due to maxmemory limit	DEPENDENT	-	redis.stats.evicted_keys
Redis: Expired keys	Total number of key expiration events	DEPENDENT	-	redis.stats.expired_keys
Redis: Instantaneous input bytes per second	The network's read rate per second in KB/sec	DEPENDENT	-	redis.stats.instantaneous_input.rate
Redis: Instantaneous operations per sec	Number of commands processed per second	DEPENDENT	-	redis.stats.instantaneous_ops.rate
Redis: Instantaneous output bytes per second	The network's write rate per second in KB/sec	DEPENDENT	-	redis.stats.instantaneous_output.rate
Redis: Keyspace hits	Number of successful lookup of keys in the main dictionary	DEPENDENT	-	redis.stats.keyspace_hits
Redis: Keyspace misses	Number of failed lookup of keys in the main dictionary	DEPENDENT	-	redis.stats.keyspace_misses
Redis: Latest fork usec	Duration of the latest fork operation in microseconds	DEPENDENT	-	redis.stats.latest_fork_usec
Redis: Migrate cached sockets	The number of sockets open for MIGRATE purposes	DEPENDENT	-	redis.stats.migrate_cached_sockets
Redis: Pubsub channels	Global number of pub/sub channels with client subscriptions	DEPENDENT	-	redis.stats.pubsub_channels
Redis: Pubsub patterns	Global number of pub/sub pattern with client subscriptions	DEPENDENT	-	redis.stats.pubsub_patterns
Redis: Rejected connections	Number of connections rejected because of maxclients limit	DEPENDENT	-	redis.stats.rejected_connections
Redis: Sync full	The number of full resyncs with replicas	DEPENDENT	-	redis.stats.sync_full
Redis: Sync partial err	The number of denied partial resync requests	DEPENDENT	-	redis.stats.sync_partial_err
Redis: Sync partial ok	The number of accepted partial resync requests	DEPENDENT	-	redis.stats.sync_partial_ok
Redis: Total commands processed	Total number of commands processed by the server	DEPENDENT	-	redis.stats.total_commands_processed
Redis: Total connections received	Total number of connections accepted by the server	DEPENDENT	-	redis.stats.total_connections_received
Redis: Total net input bytes	The total number of bytes read from the network	DEPENDENT	-	redis.stats.total_net_input_bytes
Redis: Total net output bytes	The total number of bytes written to the network	DEPENDENT	-	redis.stats.total_net_output_bytes

Triggers

Name	Description	Expression	Priority	Dependencies
Redis: Configuration has changed	Redis configuration has changed. Ack to close.	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 🔔	Redis: Get config
Redis: Failed to fetch info data	Zabbix has not received data for items for the last 30 minutes	nodata(/Redis by Zabbix agent 2/redis.info["{$REDIS.CONN.URI}"],30m)=1	WARNING 📢	Redis: Get info
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: Memory fragmentation ratio
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: AOF last write status
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: RDB last bgsave status
Redis: Service is down	-	last(/Redis by Zabbix agent 2/redis.ping["{$REDIS.CONN.URI}"])=0	AVERAGE ⚠	Redis: Ping
Redis: Number of slaves has changed	Redis number of slaves has changed. Ack to close.	last(/Redis by Zabbix agent 2/redis.replication.connected_slaves,#1)<>last(/Redis by Zabbix agent 2/redis.replication.connected_slaves,#2)	INFO 🔔	Redis: Connected slaves
Redis: Replication role has changed	Redis replication role has changed. Ack to close.	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 📢	Redis: Replication role
Redis: Version has changed	Redis version has changed. Ack to close.	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 🔔	Redis: Redis version
Redis: has been restarted	Uptime is less than 10 minutes.	last(/Redis by Zabbix agent 2/redis.server.uptime)<10m	INFO 🔔	Redis: Uptime
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: Slowlog entries per second
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 ⛔	Redis: Rejected connections

Discovery rule №1

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

Item prototypes

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

Trigger prototypes

Name	Description	Expression	Priority	Dependencies
Redis: Process is not running	-	last(/Redis by Zabbix agent 2/proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"])=0	HIGH ⛔	Redis: Number of processes running

Discovery rule №2

Name	Description	Type	Interval	Key and additional info
Keyspace discovery	Individual keyspace metrics	DEPENDENT	0	redis.keyspace.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
DB {#DB}: Average TTL	Average TTL	DEPENDENT	-	redis.db.avg_ttl["{#DB}"]
DB {#DB}: Expires	Number of keys with an expiration	DEPENDENT	-	redis.db.expires["{#DB}"]
DB {#DB}: Keys	Total number of keys	DEPENDENT	-	redis.db.keys["{#DB}"]

Discovery rule №3

Name	Description	Type	Interval	Key and additional info
Version 4+ metrics discovery	Additional metrics for versions 4+	DEPENDENT	0	redis.metrics.v4.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
Redis: Active defrag running{#SINGLETON}	Flag indicating if active defragmentation is active	DEPENDENT	-	redis.memory.active_defrag_running[{#SINGLETON}]
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	-	redis.memory.lazyfree_pending_objects[{#SINGLETON}]
Redis: Max memory{#SINGLETON}	Maximum amount of memory allocated to the Redisdb system	DEPENDENT	-	redis.memory.maxmemory[{#SINGLETON}]
Redis: Max memory policy{#SINGLETON}	The value of the maxmemory-policy configuration directive	DEPENDENT	-	redis.memory.maxmemory_policy[{#SINGLETON}]
Redis: Total system memory{#SINGLETON}	The total amount of memory that the Redis host has	DEPENDENT	-	redis.memory.total_system_memory[{#SINGLETON}]
Redis: Memory used dataset{#SINGLETON}	The size in bytes of the dataset	DEPENDENT	-	redis.memory.used_memory_dataset[{#SINGLETON}]
Redis: Memory used dataset %{#SINGLETON}	The percentage of used_memory_dataset out of the net memory usage (used_memory minus used_memory_startup)	DEPENDENT	-	redis.memory.used_memory_dataset_perc[{#SINGLETON}]
Redis: Memory used overhead{#SINGLETON}	The sum in bytes of all overheads that the server allocated for managing its internal data structures	DEPENDENT	-	redis.memory.used_memory_overhead[{#SINGLETON}]
Redis: Memory used peak %{#SINGLETON}	The percentage of used_memory_peak out of used_memory	DEPENDENT	-	redis.memory.used_memory_peak_perc[{#SINGLETON}]
Redis: Memory used startup{#SINGLETON}	Initial amount of memory consumed by Redis at startup in bytes	DEPENDENT	-	redis.memory.used_memory_startup[{#SINGLETON}]
Redis: AOF last CoW size{#SINGLETON}	The size in bytes of copy-on-write allocations during the last AOF rewrite operation	DEPENDENT	-	redis.persistence.aof_last_cow_size[{#SINGLETON}]
Redis: RDB last CoW size{#SINGLETON}	The size in bytes of copy-on-write allocations during the last RDB save operation	DEPENDENT	-	redis.persistence.rdb_last_cow_size[{#SINGLETON}]
Redis: Replication second offset{#SINGLETON}	Offset up to which replication IDs are accepted	DEPENDENT	-	redis.replication.second_repl_offset[{#SINGLETON}]
Redis: Executable path{#SINGLETON}	The path to the server's executable	DEPENDENT	-	redis.server.executable[{#SINGLETON}]
Redis: Active defrag hits{#SINGLETON}	Number of value reallocations performed by active the defragmentation process	DEPENDENT	-	redis.stats.active_defrag_hits[{#SINGLETON}]
Redis: Active defrag key hits{#SINGLETON}	Number of keys that were actively defragmented	DEPENDENT	-	redis.stats.active_defrag_key_hits[{#SINGLETON}]
Redis: Active defrag key misses{#SINGLETON}	Number of keys that were skipped by the active defragmentation process	DEPENDENT	-	redis.stats.active_defrag_key_misses[{#SINGLETON}]
Redis: Active defrag misses{#SINGLETON}	Number of aborted value reallocations started by the active defragmentation process	DEPENDENT	-	redis.stats.active_defrag_misses[{#SINGLETON}]
Redis: Expired stale %{#SINGLETON}	-	DEPENDENT	-	redis.stats.expired_stale_perc[{#SINGLETON}]
Redis: Expired time cap reached count{#SINGLETON}	-	DEPENDENT	-	redis.stats.expired_time_cap_reached_count[{#SINGLETON}]
Redis: Slave expires tracked keys{#SINGLETON}	The number of keys tracked for expiry purposes (applicable only to writable replicas)	DEPENDENT	-	redis.stats.slave_expires_tracked_keys[{#SINGLETON}]

Trigger prototypes

Name	Description	Expression	Priority	Dependencies
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 📢

Discovery rule №4

Name	Description	Type	Interval	Key and additional info
Version 5+ metrics discovery	Additional metrics for versions 5+	DEPENDENT	0	redis.metrics.v5.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
Redis: Allocator active{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_active[{#SINGLETON}]
Redis: Allocator allocated{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_allocated[{#SINGLETON}]
Redis: Allocator fragmentation bytes{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_frag_bytes[{#SINGLETON}]
Redis: Allocator fragmentation ratio{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_frag_ratio[{#SINGLETON}]
Redis: Allocator resident{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_resident[{#SINGLETON}]
Redis: Allocator RSS bytes{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_rss_bytes[{#SINGLETON}]
Redis: Allocator RSS ratio{#SINGLETON}	-	DEPENDENT	-	redis.memory.allocator_rss_ratio[{#SINGLETON}]
Redis: Memory fragmentation bytes{#SINGLETON}	-	DEPENDENT	-	redis.memory.fragmentation_bytes[{#SINGLETON}]
Redis: Memory AOF buffer{#SINGLETON}	Size of the AOF buffer	DEPENDENT	-	redis.memory.mem_aof_buffer[{#SINGLETON}]
Redis: Memory clients normal{#SINGLETON}	-	DEPENDENT	-	redis.memory.mem_clients_normal[{#SINGLETON}]
Redis: Memory clients slaves{#SINGLETON}	-	DEPENDENT	-	redis.memory.mem_clients_slaves[{#SINGLETON}]
Redis: Memory not counted for evict{#SINGLETON}	-	DEPENDENT	-	redis.memory.not_counted_for_evict[{#SINGLETON}]
Redis: Memory number of cached scripts{#SINGLETON}	-	DEPENDENT	-	redis.memory.number_of_cached_scripts[{#SINGLETON}]
Redis: Memory replication backlog{#SINGLETON}	-	DEPENDENT	-	redis.memory.replication_backlog[{#SINGLETON}]
Redis: Memory RSS overhead bytes{#SINGLETON}	-	DEPENDENT	-	redis.memory.rss_overhead_bytes[{#SINGLETON}]
Redis: Memory RSS overhead ratio{#SINGLETON}	-	DEPENDENT	-	redis.memory.rss_overhead_ratio[{#SINGLETON}]
Redis: Memory used scripts{#SINGLETON}	-	DEPENDENT	-	redis.memory.used_memory_scripts[{#SINGLETON}]

Discovery rule №5

Name	Description	Type	Interval	Key and additional info
AOF metrics discovery	If AOF is activated, additional metrics will be added	DEPENDENT	0	redis.persistence.aof.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
Redis: AOF base size{#SINGLETON}	AOF file size on latest startup or rewrite	DEPENDENT	-	redis.persistence.aof_base_size[{#SINGLETON}]
Redis: AOF buffer length{#SINGLETON}	Size of the AOF buffer	DEPENDENT	-	redis.persistence.aof_buffer_length[{#SINGLETON}]
Redis: AOF current size{#SINGLETON}	AOF current file size	DEPENDENT	-	redis.persistence.aof_current_size[{#SINGLETON}]
Redis: AOF delayed fsync{#SINGLETON}	Delayed fsync counter	DEPENDENT	-	redis.persistence.aof_delayed_fsync[{#SINGLETON}]
Redis: AOF pending background I/O fsync{#SINGLETON}	Number of fsync pending jobs in background I/O queue	DEPENDENT	-	redis.persistence.aof_pending_bio_fsync[{#SINGLETON}]
Redis: AOF pending rewrite{#SINGLETON}	Flag indicating an AOF rewrite operation will	DEPENDENT	-	redis.persistence.aof_pending_rewrite[{#SINGLETON}]
Redis: AOF rewrite buffer length{#SINGLETON}	Size of the AOF rewrite buffer	DEPENDENT	-	redis.persistence.aof_rewrite_buffer_length[{#SINGLETON}]

Discovery rule №6

Name	Description	Type	Interval	Key and additional info
Replication metrics discovery	If the instance is the master and the slaves are connected, additional metrics are provided	DEPENDENT	0	redis.replication.master.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
Redis slave {#SLAVE_IP}:{#SLAVE_PORT}: Replication lag in bytes	Replication lag in bytes	DEPENDENT	-	redis.replication.lag_bytes["{#SLAVE_IP}:{#SLAVE_PORT}"]

Discovery rule №7

Name	Description	Type	Interval	Key and additional info
Slave metrics discovery	If the instance is a replica, additional metrics are provided	DEPENDENT	0	redis.replication.slave.discovery

Item prototypes

Name	Description	Type	Interval	Key and additional info
Redis: Master host{#SINGLETON}	Host or IP address of the master	DEPENDENT	-	redis.replication.master_host[{#SINGLETON}]
Redis: Master last I/O seconds ago{#SINGLETON}	Number of seconds since the last interaction with master	DEPENDENT	-	redis.replication.master_last_io_seconds_ago[{#SINGLETON}]
Redis: Master link status{#SINGLETON}	Status of the link (up/down)	DEPENDENT	-	redis.replication.master_link_status[{#SINGLETON}]
Redis: Master port{#SINGLETON}	Master listening TCP port	DEPENDENT	-	redis.replication.master_port[{#SINGLETON}]
Redis: Master sync in progress{#SINGLETON}	Indicate the master is syncing to the replica	DEPENDENT	-	redis.replication.master_sync_in_progress[{#SINGLETON}]
Redis: Slave priority{#SINGLETON}	The priority of the instance as a candidate for failover	DEPENDENT	-	redis.replication.slave_priority[{#SINGLETON}]
Redis: Slave priority{#SINGLETON}	Flag indicating if the replica is read-only	DEPENDENT	-	redis.replication.slave_read_only[{#SINGLETON}]
Redis: Slave replication offset{#SINGLETON}	The replication offset of the replica instance	DEPENDENT	-	redis.replication.slave_repl_offset[{#SINGLETON}]

Trigger prototypes

Name	Description	Expression	Priority	Dependencies
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 📢	Redis: Master last I/O seconds ago{#SINGLETON}