Redis

Redis

Redis is an in-memory data structure project implementing a distributed, in-memory key-value database with optional durability. Redis supports different kinds of abstract data structures, such as strings, lists, maps, sets, sorted sets, HyperLogLogs, bitmaps, streams, and spatial indexes.

Available solutions




This template is for Zabbix version: 7.4

Source: https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/db/redis?at=release/7.4

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.4 and higher.

Tested versions

This template has been tested on:

  • Redis versions 8.8

Configuration

Zabbix should be configured according to the instructions in the Templates out of the box section.

Setup

  • Set up and configure zabbix-agent2 compiled with the Redis monitoring plugin.

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

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

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

Optional setup

Memory overhead triggers

The template includes three memory-related triggers, available from Redis 5.0 onward, each flagging a different source of memory overhead: fragmentation within the allocator (memory allocator fragmentation trigger), memory retained by the allocator but not actively used (allocator RSS ratio trigger), and process memory outside the allocator (RSS overhead ratio trigger).

Each trigger combines a ratio threshold with a minimum bytes guard, controlled by user macros:

{$REDIS.MEM.ALLOC_FRAG_RATIO.MAX.WARN} and {$REDIS.MEM.ALLOC_FRAG_BYTES.MIN},

{$REDIS.MEM.ALLOC_RSS_RATIO.MAX.WARN} and {$REDIS.MEM.ALLOC_RSS_BYTES.MIN},

{$REDIS.MEM.RSS_OVERHEAD_RATIO.MAX.WARN} and {$REDIS.MEM.RSS_OVERHEAD_BYTES.MIN}.

The bytes guard exists to avoid false positives on small or freshly started instances. The values of these macros can be adjusted per host to tune sensitivity to your environment.

Macros used

Name Description Default
{$REDIS.CONN.URI}

Connection string in URI format.

When set, this parameter overrides the value specified in the Server option of the configuration file.

Otherwise, the plugin's default value is used: tcp://localhost:6379.

 tcp://localhost:6379
{$REDIS.USERNAME}

Username for Redis server authentication.
{$REDIS.PASSWORD}

Password for Redis server authentication.
{$REDIS.SECTION}

Section of Redis server information to retrieve.
{$REDIS.PATTERN}

Pattern for filtering Redis server configuration parameters.
{$REDIS.PROCESS_NAME}

Name of the Redis server process to monitor.

 redis-server
{$REDIS.LLD.PROCESS_NAME}

Redis process name used during LLD.

 redis-server
{$REDIS.LLD.FILTER.DB.MATCHES}

Regex pattern for databases to include during discovery.

 .*
{$REDIS.LLD.FILTER.DB.NOT_MATCHES}

Regex pattern for databases to exclude during discovery.

 CHANGE_IF_NEEDED
{$REDIS.REPL.LAG.MAX.WARN}

Maximum replication lag allowed between Redis master and replica, in seconds.

 30s
{$REDIS.SLOWLOG.COUNT.MAX.WARN}

Slowlog entry rate threshold that triggers a warning.

 1
{$REDIS.CLIENTS.PRC.MAX.WARN}

Threshold for the maximum percentage of connected Redis clients.

 80
{$REDIS.MEM.PUSED.MAX.WARN}

Maximum percentage of memory used by the Redis server.

 90
{$REDIS.MEM.ALLOC_FRAG_RATIO.MAX.WARN}

Threshold for the Redis memory allocator fragmentation ratio.

 1.5
{$REDIS.MEM.ALLOC_FRAG_BYTES.MIN}

Minimum allocator fragmentation bytes required before the memory fragmentation trigger fires.

 100M
{$REDIS.MEM.ALLOC_RSS_RATIO.MAX.WARN}

Threshold for the Redis allocator RSS ratio.

 1.5
{$REDIS.MEM.ALLOC_RSS_BYTES.MIN}

Minimum allocator RSS bytes required before the allocator RSS ratio trigger fires.

 100M
{$REDIS.MEM.RSS_OVERHEAD_RATIO.MAX.WARN}

Threshold for the Redis RSS overhead ratio.

 1.5
{$REDIS.MEM.RSS_OVERHEAD_BYTES.MIN}

Minimum RSS overhead bytes required before the RSS overhead ratio trigger fires.

 100M

Items

Name Description Type Key and additional info
Get info

Retrieves general Redis server information and statistics.

 Zabbix agent redis.info["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.SECTION}","{$REDIS.USERNAME}"]
Get config

Extracts Redis server info.

 Zabbix agent redis.config["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.PATTERN}","{$REDIS.USERNAME}"]

Preprocessing

  • Discard unchanged with heartbeat: 1h
Ping

Verifies Redis server connectivity.

 Zabbix agent redis.ping["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.USERNAME}"]

Preprocessing

  • Discard unchanged with heartbeat: 10m
Slowlog entries per second

Tracks SLOWLOG entry rate on the Redis server.

 Zabbix agent redis.slowlog.count["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.USERNAME}"]

Preprocessing

  • Change per second
Get Client info

Extracts client-related information from the Redis server.

 Dependent item redis.clients.info_raw

Preprocessing

  • JSON Path: $.Clients

    ⛔️Custom on fail: Discard value
Get CPU info

Extracts CPU usage data from the Redis server.

 Dependent item redis.cpu.info_raw

Preprocessing

  • JSON Path: $.CPU

    ⛔️Custom on fail: Discard value
Get Keyspace info

Extracts keyspace data from the Redis server.

 Dependent item redis.keyspace.info_raw

Preprocessing

  • JSON Path: $.Keyspace

    ⛔️Custom on fail: Discard value
Get Memory info

Extracts memory data from the Redis server.

 Dependent item redis.memory.info_raw

Preprocessing

  • JSON Path: $.Memory

    ⛔️Custom on fail: Discard value
Get Persistence info

Collects persistence data from the Redis server.

 Dependent item redis.persistence.info_raw

Preprocessing

  • JSON Path: $.Persistence

    ⛔️Custom on fail: Discard value
Get Replication info

Extracts replication data from the Redis server.

 Dependent item redis.replication.info_raw

Preprocessing

  • JSON Path: $.Replication

    ⛔️Custom on fail: Discard value
Get Server info

Retrieves Redis server information.

 Dependent item redis.server.info_raw

Preprocessing

  • JSON Path: $.Server

    ⛔️Custom on fail: Discard value
Get Stats info

Collects Redis server statistics.

 Dependent item redis.stats.info_raw

Preprocessing

  • JSON Path: $.Stats

    ⛔️Custom on fail: Discard value
CPU sys

Retrieves Redis Server CPU usage (system).

 Dependent item redis.cpu.sys

Preprocessing

  • JSON Path: $.used_cpu_sys
CPU sys children

Retrieves system CPU usage of the Redis server child processes.

 Dependent item redis.cpu.sys_children

Preprocessing

  • JSON Path: $.used_cpu_sys_children
CPU user

Collects user CPU usage data from the Redis server.

 Dependent item redis.cpu.user

Preprocessing

  • JSON Path: $.used_cpu_user
CPU user children

Retrieves user-level CPU usage of Redis server child processes.

 Dependent item redis.cpu.user_children

Preprocessing

  • JSON Path: $.used_cpu_user_children
Blocked clients

Retrieves blocked clients from the Redis server.

 Dependent item redis.clients.blocked

Preprocessing

  • JSON Path: $.blocked_clients
Max input buffer

Monitors maximum input buffer size of Redis server clients.

 Dependent item redis.clients.max_input_buffer

Preprocessing

  • JavaScript: The text is too long. Please see the template.
Max output buffer

Monitors maximum output buffer size of Redis server clients.

 Dependent item redis.clients.max_output_buffer

Preprocessing

  • JavaScript: The text is too long. Please see the template.
Connected clients

Monitors the number of active Redis server clients.

 Dependent item redis.clients.connected

Preprocessing

  • JSON Path: $.connected_clients
Cluster enabled

Indicates if Redis server cluster mode is enabled.

 Dependent item redis.cluster.enabled

Preprocessing

  • JSON Path: $.Cluster.cluster_enabled
Memory used

Monitors the memory used by the Redis server.

 Dependent item redis.memory.used_memory

Preprocessing

  • JSON Path: $.used_memory
Memory used Lua

Monitors the memory used by Lua scripts in the Redis server.

 Dependent item redis.memory.used_memory_lua

Preprocessing

  • JSON Path: $.used_memory_lua
Memory used peak

Monitors peak memory usage of the Redis server.

 Dependent item redis.memory.used_memory_peak

Preprocessing

  • JSON Path: $.used_memory_peak
Memory used RSS

Monitors resident memory (RSS) used by the Redis server.

 Dependent item redis.memory.used_memory_rss

Preprocessing

  • JSON Path: $.used_memory_rss
Memory fragmentation ratio

Ratio between used_memory_rss and used_memory.

Note: This metric does not measure memory fragmentation directly.

It includes other process overheads such as shared libraries, code, stack, and other allocator overheads

(see allocator_frag_ratio for actual fragmentation).

 Dependent item redis.memory.fragmentation_ratio

Preprocessing

  • JSON Path: $.mem_fragmentation_ratio
AOF current rewrite time sec

Monitors the current AOF rewrite time on the Redis server.

 Dependent item redis.persistence.aof_current_rewrite_time_sec

Preprocessing

  • JSON Path: $.aof_current_rewrite_time_sec
AOF enabled

Indicates if AOF persistence is enabled on the Redis server.

 Dependent item redis.persistence.aof_enabled

Preprocessing

  • JSON Path: $.aof_enabled
AOF last bgrewrite status

Shows the status of the last AOF background rewrite on the Redis server.

 Dependent item redis.persistence.aof_last_bgrewrite_status

Preprocessing

  • JSON Path: $.aof_last_bgrewrite_status

  • Boolean to decimal
AOF last rewrite time sec

Shows the duration of the last AOF rewrite in seconds on the Redis server.

 Dependent item redis.persistence.aof_last_rewrite_time_sec

Preprocessing

  • JSON Path: $.aof_last_rewrite_time_sec
AOF last write status

Shows the status of the last AOF write on the Redis server.

 Dependent item redis.persistence.aof_last_write_status

Preprocessing

  • JSON Path: $.aof_last_write_status

  • Boolean to decimal
AOF rewrite in progress

Indicates if an AOF rewrite is currently in progress on the Redis server.

 Dependent item redis.persistence.aof_rewrite_in_progress

Preprocessing

  • JSON Path: $.aof_rewrite_in_progress
AOF rewrite scheduled

Indicates if an AOF rewrite is scheduled on the Redis server.

 Dependent item redis.persistence.aof_rewrite_scheduled

Preprocessing

  • JSON Path: $.aof_rewrite_scheduled
Dump loading

Indicates if the Redis server is currently loading a dump file.

 Dependent item redis.persistence.loading

Preprocessing

  • JSON Path: $.loading
RDB bgsave in progress

Indicates if an RDB BGSAVE is currently in progress on the Redis server.

 Dependent item redis.persistence.rdb_bgsave_in_progress

Preprocessing

  • JSON Path: $.rdb_bgsave_in_progress
RDB changes since last save

Shows the number of changes since the last RDB save on the Redis server.

 Dependent item redis.persistence.rdb_changes_since_last_save

Preprocessing

  • JSON Path: $.rdb_changes_since_last_save
RDB current bgsave time sec

Monitors the current RDB BGSAVE duration in the Redis server.

 Dependent item redis.persistence.rdb_current_bgsave_time_sec

Preprocessing

  • JSON Path: $.rdb_current_bgsave_time_sec
RDB last bgsave status

Shows the status of the last RDB BGSAVE operation in the Redis server.

 Dependent item redis.persistence.rdb_last_bgsave_status

Preprocessing

  • JSON Path: $.rdb_last_bgsave_status

  • Boolean to decimal
RDB last bgsave time sec

Monitors the last RDB BGSAVE duration in the Redis server.

 Dependent item redis.persistence.rdb_last_bgsave_time_sec

Preprocessing

  • JSON Path: $.rdb_last_bgsave_time_sec
RDB last save time

Shows the timestamp of the last RDB save on the Redis server.

 Dependent item redis.persistence.rdb_last_save_time

Preprocessing

  • JSON Path: $.rdb_last_save_time
Connected slaves

Shows the number of connected Redis slave servers.

 Dependent item redis.replication.connected_slaves

Preprocessing

  • JSON Path: $.connected_slaves
Replication backlog active

Indicates if the replication backlog is active on the Redis server.

 Dependent item redis.replication.repl_backlog_active

Preprocessing

  • JSON Path: $.repl_backlog_active
Replication backlog first byte offset

Shows the offset of the first byte in the Redis server replication backlog.

 Dependent item redis.replication.repl_backlog_first_byte_offset

Preprocessing

  • JSON Path: $.repl_backlog_first_byte_offset
Replication backlog history length

Shows the length of the Redis server replication backlog history.

 Dependent item redis.replication.repl_backlog_histlen

Preprocessing

  • JSON Path: $.repl_backlog_histlen
Replication backlog size

Shows the size of the Redis server replication backlog.

 Dependent item redis.replication.repl_backlog_size

Preprocessing

  • JSON Path: $.repl_backlog_size
Replication role

Shows the Redis server replication role (master or slave) from the replication info.

 Dependent item redis.replication.role

Preprocessing

  • JSON Path: $.role

  • Discard unchanged with heartbeat: 1d
Master replication offset

Shows the master replication offset on the Redis server.

 Dependent item redis.replication.master_repl_offset

Preprocessing

  • JSON Path: $.master_repl_offset
Process id

Retrieves the Redis server process identifier.

 Dependent item redis.server.process_id

Preprocessing

  • JSON Path: $.process_id

  • Discard unchanged with heartbeat: 1d
Redis mode

Retrieves the current Redis server mode (standalone, sentinel, or cluster).

 Dependent item redis.server.redis_mode

Preprocessing

  • JSON Path: $.redis_mode

  • Discard unchanged with heartbeat: 1d
Redis version

Version of the Redis server.

 Dependent item redis.server.redis_version

Preprocessing

  • JSON Path: $.redis_version

  • Discard unchanged with heartbeat: 1d
TCP port

Shows the TCP port used by the Redis server.

 Dependent item redis.server.tcp_port

Preprocessing

  • JSON Path: $.tcp_port

  • Discard unchanged with heartbeat: 1d
Uptime

Shows Redis server uptime.

 Dependent item redis.server.uptime

Preprocessing

  • JSON Path: $.uptime_in_seconds
Evicted keys

Number of keys evicted by the Redis server due to the maxmemory limit.

 Dependent item redis.stats.evicted_keys

Preprocessing

  • JSON Path: $.evicted_keys
Expired keys

Total number of keys expired on the Redis server.

 Dependent item redis.stats.expired_keys

Preprocessing

  • JSON Path: $.expired_keys
Instantaneous input bytes per second

Instantaneous network read rate in KB/sec on the Redis server.

 Dependent item redis.stats.instantaneous_input.rate

Preprocessing

  • JSON Path: $.instantaneous_input_kbps

  • Custom multiplier: 1024
Instantaneous operations per sec

Shows the number of operations processed per second by the Redis server.

 Dependent item redis.stats.instantaneous_ops.rate

Preprocessing

  • JSON Path: $.instantaneous_ops_per_sec
Instantaneous output bytes per second

Instantaneous network write rate in KB/sec on the Redis server.

 Dependent item redis.stats.instantaneous_output.rate

Preprocessing

  • JSON Path: $.instantaneous_output_kbps

  • Custom multiplier: 1024
Keyspace hits

Number of successful key lookups in the Redis main dictionary.

 Dependent item redis.stats.keyspace_hits

Preprocessing

  • JSON Path: $.keyspace_hits
Keyspace misses

Number of failed key lookups in the Redis server main dictionary.

 Dependent item redis.stats.keyspace_misses

Preprocessing

  • JSON Path: $.keyspace_misses
Latest fork usec

Duration of the latest Redis server fork operation in microseconds.

 Dependent item redis.stats.latest_fork_usec

Preprocessing

  • JSON Path: $.latest_fork_usec

  • Custom multiplier: 1e-05
Migrate cached sockets

Number of sockets currently open for the Redis server MIGRATE operations.

 Dependent item redis.stats.migrate_cached_sockets

Preprocessing

  • JSON Path: $.migrate_cached_sockets
Pubsub channels

Total number of Redis server pub/sub channels with active client subscriptions.

 Dependent item redis.stats.pubsub_channels

Preprocessing

  • JSON Path: $.pubsub_channels
Pubsub patterns

Total number of Redis pub/sub patterns with active client subscriptions.

 Dependent item redis.stats.pubsub_patterns

Preprocessing

  • JSON Path: $.pubsub_patterns
Rejected connections

Number of connections rejected by the Redis server due to the maxclients limit.

 Dependent item redis.stats.rejected_connections

Preprocessing

  • JSON Path: $.rejected_connections
Sync full

Number of full resynchronizations with Redis server replicas.

 Dependent item redis.stats.sync_full

Preprocessing

  • JSON Path: $.sync_full
Sync partial err

Number of denied partial resynchronization requests on the Redis server.

 Dependent item redis.stats.sync_partial_err

Preprocessing

  • JSON Path: $.sync_partial_err
Sync partial ok

Number of accepted partial resynchronization requests on the Redis server.

 Dependent item redis.stats.sync_partial_ok

Preprocessing

  • JSON Path: $.sync_partial_ok
Total commands processed

Total number of commands processed by the Redis server.

 Dependent item redis.stats.total_commands_processed

Preprocessing

  • JSON Path: $.total_commands_processed
Total connections received

Total number of connections received by the Redis server.

 Dependent item redis.stats.total_connections_received

Preprocessing

  • JSON Path: $.total_connections_received
Total net input bytes

Total number of bytes read by the Redis server from the network.

 Dependent item redis.stats.total_net_input_bytes

Preprocessing

  • JSON Path: $.total_net_input_bytes
Total net output bytes

Total number of bytes written by the Redis server to the network.

 Dependent item redis.stats.total_net_output_bytes

Preprocessing

  • JSON Path: $.total_net_output_bytes
Max clients

Max number of connected clients at the same time.

Once the limit is reached Redis will close all the new connections sending an error "max number of clients reached".

 Dependent item redis.config.maxclients

Preprocessing

  • JSON Path: $.maxclients

  • Discard unchanged with heartbeat: 30m

Triggers

Name Description Expression Severity Dependencies and additional info
Redis: Failed to fetch INFO

Zabbix has not received any item data for the last 30 minutes.

 nodata(/Redis by Zabbix agent 2/redis.info["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.SECTION}","{$REDIS.USERNAME}"],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}","{$REDIS.PASSWORD}","{$REDIS.PATTERN}","{$REDIS.USERNAME}"],#1)<>last(/Redis by Zabbix agent 2/redis.config["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.PATTERN}","{$REDIS.USERNAME}"],#2) and length(last(/Redis by Zabbix agent 2/redis.config["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.PATTERN}","{$REDIS.USERNAME}"]))>0 Info Manual close: Yes
Redis: Service is down last(/Redis by Zabbix agent 2/redis.ping["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.USERNAME}"])=0 Average Manual close: Yes
Redis: Too many entries in the slowlog min(/Redis by Zabbix agent 2/redis.slowlog.count["{$REDIS.CONN.URI}","{$REDIS.PASSWORD}","{$REDIS.USERNAME}"],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: 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

Number of connections rejected after Redis server reached the maxclients limit.

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

Metrics for individual Redis server keyspaces.

 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 the keyspace of database {#DB}.

 Dependent item redis.db.info_raw["{#DB}"]

Preprocessing

  • JSON Path: $['{#DB}']

    ⛔️Custom on fail: Discard value
DB {#DB}: Average TTL

Average TTL.

 Dependent item redis.db.avg_ttl["{#DB}"]

Preprocessing

  • JSON Path: $.avg_ttl

  • Custom multiplier: 0.001
DB {#DB}: Expires

Number of keys with an expiration set.

 Dependent item redis.db.expires["{#DB}"]

Preprocessing

  • JSON Path: $.expires
DB {#DB}: Keys

Total number of keys.

 Dependent item redis.db.keys["{#DB}"]

Preprocessing

  • JSON Path: $.keys

LLD rule AOF metrics discovery

Name Description Type Key and additional info
AOF metrics discovery

If AOF is activated, additional metrics will be added.

 Dependent item redis.persistence.aof.discovery

Preprocessing

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

Item prototypes for AOF metrics discovery

Name Description Type Key and additional info
AOF current size{#SINGLETON}

AOF current file size.

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

Preprocessing

  • JSON Path: $.aof_current_size
AOF base size{#SINGLETON}

AOF file size on latest startup or rewrite.

 Dependent item redis.persistence.aof_base_size[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_base_size
AOF pending rewrite{#SINGLETON}

Flag indicating an AOF rewrite operation is pending.

 Dependent item redis.persistence.aof_pending_rewrite[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_pending_rewrite
AOF buffer length{#SINGLETON}

Size of the AOF buffer.

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

Preprocessing

  • JSON Path: $.aof_buffer_length
AOF rewrite buffer length{#SINGLETON}

Size of the AOF rewrite buffer.

 Dependent item redis.persistence.aof_rewrite_buffer_length[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_rewrite_buffer_length

    ⛔️Custom on fail: Discard value
AOF pending background I/O fsync{#SINGLETON}

Number of pending fsync jobs in the background I/O queue.

 Dependent item redis.persistence.aof_pending_bio_fsync[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_pending_bio_fsync
AOF delayed fsync{#SINGLETON}

Count of delayed fsync jobs.

 Dependent item redis.persistence.aof_delayed_fsync[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_delayed_fsync

LLD rule Slave metrics discovery

Name Description Type Key and additional info
Slave metrics discovery

If the instance is a replica, additional metrics are provided.

 Dependent item redis.replication.slave.discovery

Preprocessing

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

Item prototypes for Slave metrics discovery

Name Description Type Key and additional info
Master host{#SINGLETON}

Host or IP address of the master.

 Dependent item redis.replication.master_host[{#SINGLETON}]

Preprocessing

  • JSON Path: $.master_host

  • Discard unchanged with heartbeat: 1d
Master port{#SINGLETON}

TCP port the master is listening on.

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

Preprocessing

  • JSON Path: $.master_port

  • Discard unchanged with heartbeat: 1d
Master link status{#SINGLETON}

Status of the link (up/down).

 Dependent item redis.replication.master_link_status[{#SINGLETON}]

Preprocessing

  • JSON Path: $.master_link_status

  • Boolean to decimal
Master last I/O seconds ago{#SINGLETON}

Number of seconds since the last interaction with the master.

 Dependent item redis.replication.master_last_io_seconds_ago[{#SINGLETON}]

Preprocessing

  • JSON Path: $.master_last_io_seconds_ago
Master sync in progress{#SINGLETON}

Indicates the master is syncing to the replica.

 Dependent item redis.replication.master_sync_in_progress[{#SINGLETON}]

Preprocessing

  • JSON Path: $.master_sync_in_progress
Slave replication offset{#SINGLETON}

The replication offset of the replica instance.

 Dependent item redis.replication.slave_repl_offset[{#SINGLETON}]

Preprocessing

  • JSON Path: $.slave_repl_offset
Slave priority{#SINGLETON}

The priority of the instance as a candidate for failover.

 Dependent item redis.replication.slave_priority[{#SINGLETON}]

Preprocessing

  • JSON Path: $.slave_priority
Slave priority{#SINGLETON}

Flag indicating if the replica is read-only.

 Dependent item redis.replication.slave_read_only[{#SINGLETON}]

Preprocessing

  • JSON Path: $.slave_read_only

  • Discard unchanged with heartbeat: 1d

Trigger prototypes for Slave metrics discovery

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

LLD rule Replication metrics discovery

Name Description Type Key and additional info
Replication metrics discovery

If the instance is the master and the slaves are connected, additional metrics are provided.

 Dependent item redis.replication.master.discovery

Preprocessing

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

Item prototypes for Replication metrics discovery

Name Description Type Key and additional info
Redis slave {#SLAVE_IP}:{#SLAVE_PORT}: Replication lag in bytes

Replication lag, in bytes.

 Dependent item redis.replication.lag_bytes["{#SLAVE_IP}:{#SLAVE_PORT}"]

Preprocessing

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

LLD rule Process metrics discovery

Name Description Type Key and additional info
Process metrics discovery

Collect metrics by Zabbix agent if it exists.

 Zabbix agent proc.num["{$REDIS.LLD.PROCESS_NAME}"]

Preprocessing

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

Item prototypes for Process metrics discovery

Name Description Type Key and additional info
Number of running processes

Number of running processes on the Redis server.

 Zabbix agent proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"]
Memory usage (rss)

Resident Set Size memory used by the process, in bytes.

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

Virtual memory size used by the process, in bytes.

 Zabbix agent proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,vsize]
CPU utilization

Process CPU utilization percentage.

 Zabbix agent proc.cpu.util["{$REDIS.PROCESS_NAME}{#SINGLETON}"]

Trigger prototypes for Process metrics discovery

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

LLD rule Version 4+ metrics discovery

Name Description Type Key and additional info
Version 4+ metrics discovery

Additional metrics for versions 4+.

 Dependent item redis.metrics.v4.discovery

Preprocessing

  • JSON Path: $.redis_version

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

Item prototypes for Version 4+ metrics discovery

Name Description Type Key and additional info
Executable path{#SINGLETON}

The path to the server's executable.

 Dependent item redis.server.executable[{#SINGLETON}]

Preprocessing

  • JSON Path: $.executable

  • Discard unchanged with heartbeat: 1d
Memory used peak %{#SINGLETON}

The percentage of used_memory_peak out of used_memory.

 Dependent item redis.memory.used_memory_peak_perc[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_peak_perc

  • Regular expression: (.+)% \1
Memory used overhead{#SINGLETON}

The sum in bytes of all overheads that the server allocated for managing its internal data structures.

 Dependent item redis.memory.used_memory_overhead[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_overhead
Memory used startup{#SINGLETON}

Initial amount of memory consumed by Redis at startup, in bytes.

 Dependent item redis.memory.used_memory_startup[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_startup
Memory used dataset{#SINGLETON}

The size in bytes of the dataset.

 Dependent item redis.memory.used_memory_dataset[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_dataset
Memory used dataset %{#SINGLETON}

The percentage of used_memory_dataset out of the net memory usage (used_memory minus used_memory_startup).

 Dependent item redis.memory.used_memory_dataset_perc[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_dataset_perc

  • Regular expression: (.+)% \1
Total system memory{#SINGLETON}

The total amount of memory of the Redis host.

 Dependent item redis.memory.total_system_memory[{#SINGLETON}]

Preprocessing

  • JSON Path: $.total_system_memory
Max memory{#SINGLETON}

Maximum amount of memory allocated to the Redis server.

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

Preprocessing

  • JSON Path: $.maxmemory
Max memory policy{#SINGLETON}

The value of the maxmemory-policy configuration directive.

 Dependent item redis.memory.maxmemory_policy[{#SINGLETON}]

Preprocessing

  • JSON Path: $.maxmemory_policy

  • Discard unchanged with heartbeat: 1d
Active defrag running{#SINGLETON}

Flag indicating if active defragmentation is active.

 Dependent item redis.memory.active_defrag_running[{#SINGLETON}]

Preprocessing

  • JSON Path: $.active_defrag_running
Lazyfree pending objects{#SINGLETON}

The number of objects waiting to be freed (as a result of calling UNLINK, or FLUSHDB and FLUSHALL with the ASYNC option).

 Dependent item redis.memory.lazyfree_pending_objects[{#SINGLETON}]

Preprocessing

  • JSON Path: $.lazyfree_pending_objects
RDB last CoW size{#SINGLETON}

The size in bytes of copy-on-write allocations during the last RDB save operation.

 Dependent item redis.persistence.rdb_last_cow_size[{#SINGLETON}]

Preprocessing

  • JSON Path: $.rdb_last_cow_size
AOF last CoW size{#SINGLETON}

The size in bytes of copy-on-write allocations during the last AOF rewrite operation.

 Dependent item redis.persistence.aof_last_cow_size[{#SINGLETON}]

Preprocessing

  • JSON Path: $.aof_last_cow_size
Expired stale %{#SINGLETON}

Number of stale keys expired by the Redis server.

 Dependent item redis.stats.expired_stale_perc[{#SINGLETON}]

Preprocessing

  • JSON Path: $.expired_stale_perc
Expired time cap reached count{#SINGLETON}

Number of keys expired due to reaching the time limit on the Redis server.

 Dependent item redis.stats.expired_time_cap_reached_count[{#SINGLETON}]

Preprocessing

  • JSON Path: $.expired_time_cap_reached_count
Slave expires tracked keys{#SINGLETON}

The number of keys tracked for expiry purposes (applicable only to writable replicas).

 Dependent item redis.stats.slave_expires_tracked_keys[{#SINGLETON}]

Preprocessing

  • JSON Path: $.slave_expires_tracked_keys
Active defrag hits{#SINGLETON}

Number of value reallocations performed by the active defragmentation process.

 Dependent item redis.stats.active_defrag_hits[{#SINGLETON}]

Preprocessing

  • JSON Path: $.active_defrag_hits
Active defrag misses{#SINGLETON}

Number of aborted value reallocations started by the active defragmentation process.

 Dependent item redis.stats.active_defrag_misses[{#SINGLETON}]

Preprocessing

  • JSON Path: $.active_defrag_misses
Active defrag key hits{#SINGLETON}

Number of keys that were actively defragmented.

 Dependent item redis.stats.active_defrag_key_hits[{#SINGLETON}]

Preprocessing

  • JSON Path: $.active_defrag_key_hits
Active defrag key misses{#SINGLETON}

Number of keys that were skipped by the active defragmentation process.

 Dependent item redis.stats.active_defrag_key_misses[{#SINGLETON}]

Preprocessing

  • JSON Path: $.active_defrag_key_misses
Replication second offset{#SINGLETON}

Offset up to which replication IDs are accepted.

 Dependent item redis.replication.second_repl_offset[{#SINGLETON}]

Preprocessing

  • JSON Path: $.second_repl_offset

Trigger prototypes for Version 4+ metrics discovery

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

LLD rule Version 5+ metrics discovery

Name Description Type Key and additional info
Version 5+ metrics discovery

Additional metrics for versions 5+.

 Dependent item redis.metrics.v5.discovery

Preprocessing

  • JSON Path: $.redis_version

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

Item prototypes for Version 5+ metrics discovery

Name Description Type Key and additional info
Allocator active{#SINGLETON}

Active memory allocated by the Redis server allocator.

 Dependent item redis.memory.allocator_active[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_active
Allocator allocated{#SINGLETON}

Total memory allocated by the Redis server allocator.

 Dependent item redis.memory.allocator_allocated[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_allocated
Allocator resident{#SINGLETON}

Resident memory used by the Redis server allocator.

 Dependent item redis.memory.allocator_resident[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_resident
Memory used scripts{#SINGLETON}

Memory used by scripts on the Redis server.

 Dependent item redis.memory.used_memory_scripts[{#SINGLETON}]

Preprocessing

  • JSON Path: $.used_memory_scripts
Memory number of cached scripts{#SINGLETON}

Number of scripts cached in the Redis server.

 Dependent item redis.memory.number_of_cached_scripts[{#SINGLETON}]

Preprocessing

  • JSON Path: $.number_of_cached_scripts
Allocator fragmentation bytes{#SINGLETON}

Memory fragmentation in bytes reported by the Redis server allocator.

 Dependent item redis.memory.allocator_frag_bytes[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_frag_bytes
Allocator fragmentation ratio{#SINGLETON}

Memory fragmentation ratio of the Redis server allocator.

 Dependent item redis.memory.allocator_frag_ratio[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_frag_ratio
Allocator RSS bytes{#SINGLETON}

Resident Set Size (RSS) in bytes used by the Redis server allocator.

 Dependent item redis.memory.allocator_rss_bytes[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_rss_bytes
Allocator RSS ratio{#SINGLETON}

RSS ratio of the Redis server allocator.

 Dependent item redis.memory.allocator_rss_ratio[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_rss_ratio
Memory RSS overhead bytes{#SINGLETON}

Memory RSS overhead in bytes on the Redis server.

 Dependent item redis.memory.rss_overhead_bytes[{#SINGLETON}]

Preprocessing

  • JSON Path: $.rss_overhead_bytes
Memory RSS overhead ratio{#SINGLETON}

Memory RSS overhead ratio on the Redis server.

 Dependent item redis.memory.rss_overhead_ratio[{#SINGLETON}]

Preprocessing

  • JSON Path: $.rss_overhead_ratio
Memory fragmentation bytes{#SINGLETON}

Total memory fragmentation in bytes on the Redis server.

 Dependent item redis.memory.fragmentation_bytes[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_fragmentation_bytes
Memory not counted for evict{#SINGLETON}

Memory not counted for eviction on the Redis server.

 Dependent item redis.memory.not_counted_for_evict[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_not_counted_for_evict
Memory replication backlog{#SINGLETON}

Memory used by the Redis server replication backlog.

 Dependent item redis.memory.replication_backlog[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_replication_backlog
Memory clients normal{#SINGLETON}

Memory used by normal client connections on the Redis server.

 Dependent item redis.memory.mem_clients_normal[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_clients_normal
Memory clients slaves{#SINGLETON}

Memory used by slave client connections on the Redis server.

 Dependent item redis.memory.mem_clients_slaves[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_clients_slaves
Memory AOF buffer{#SINGLETON}

Size of the AOF buffer on the Redis server.

 Dependent item redis.memory.mem_aof_buffer[{#SINGLETON}]

Preprocessing

  • JSON Path: $.mem_aof_buffer

Trigger prototypes for Version 5+ metrics discovery

Name Description Expression Severity Dependencies and additional info
Redis: Memory allocator fragmentation is too high

Memory fragmentation at the allocator level indicates how efficiently the memory allocator is using physical memory:
- Value over 1.5 means the allocator has significantly more fragmented memory than necessary.
Consider enabling active defragmentation (activedefrag yes) or restarting Redis to reclaim fragmented memory.
- Low fragmentation (close to 1.0) is normal and expected.

 min(/Redis by Zabbix agent 2/redis.memory.allocator_frag_ratio[{#SINGLETON}],15m)>{$REDIS.MEM.ALLOC_FRAG_RATIO.MAX.WARN} and last(/Redis by Zabbix agent 2/redis.memory.allocator_frag_bytes[{#SINGLETON}])>{$REDIS.MEM.ALLOC_FRAG_BYTES.MIN} Warning
Redis: Allocator RSS ratio is too high

Ratio between allocator_resident and allocator_active.
Indicates pages that the allocator can and probably will soon release
back to the OS. If sustained, consider running MEMORY PURGE.

 min(/Redis by Zabbix agent 2/redis.memory.allocator_rss_ratio[{#SINGLETON}],15m)>{$REDIS.MEM.ALLOC_RSS_RATIO.MAX.WARN} and last(/Redis by Zabbix agent 2/redis.memory.allocator_rss_bytes[{#SINGLETON}])>{$REDIS.MEM.ALLOC_RSS_BYTES.MIN} Warning
Redis: RSS overhead ratio is too high

Ratio between used_memory_rss (the process RSS) and allocator_resident.
Includes RSS overheads that are not allocator or heap related.
If sustained, investigate persistence configuration (BGSAVE frequency, AOF rewrite settings).

 min(/Redis by Zabbix agent 2/redis.memory.rss_overhead_ratio[{#SINGLETON}],15m)>{$REDIS.MEM.RSS_OVERHEAD_RATIO.MAX.WARN} and last(/Redis by Zabbix agent 2/redis.memory.rss_overhead_bytes[{#SINGLETON}])>{$REDIS.MEM.RSS_OVERHEAD_BYTES.MIN} Warning

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

Articles and documentation

+ Propose new article

Не нашли то, что искали?

Закажите собственную интеграцию

Команда интеграторов Zabbix разработает индивидуальную интеграцию на основе ваших требований и лучших практик Zabbix.

Заказать

Предложите свою интеграцию

Вы уже разработали качественную интеграцию и хотите добавить ее в базу готовых интеграций Zabbix?

Предложить