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: 6.4
Also available for: 6.2 6.0 5.4 5.0

Source: https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/db/redis?at=release/6.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: 6.4 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 an 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: $['{#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

Articles and documentation

+ Propose new article

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

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

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

Заказать

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

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

Предложить