zabbix/templates/db/redis/README.md

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

You can also provide feedback, discuss the template, or ask for help at ZABBIX forums