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.0

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

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.2.4

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.

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

Or default user ACL should have @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]

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
Get info Zabbix agent redis.info["{$REDIS.CONN.URI}"]
Get config Zabbix agent redis.config["{$REDIS.CONN.URI}"]

Preprocessing

  • Discard unchanged with heartbeat: 1h

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

Preprocessing

  • Discard unchanged with heartbeat: 10m

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

Preprocessing

  • Change per second
Get Clients info Dependent item redis.clients.info_raw

Preprocessing

  • JSON Path: $.Clients

    ⛔️Custom on fail: Discard value

Get CPU info Dependent item redis.cpu.info_raw

Preprocessing

  • JSON Path: $.CPU

    ⛔️Custom on fail: Discard value

Get Keyspace info Dependent item redis.keyspace.info_raw

Preprocessing

  • JSON Path: $.Keyspace

    ⛔️Custom on fail: Discard value

Get Memory info Dependent item redis.memory.info_raw

Preprocessing

  • JSON Path: $.Memory

    ⛔️Custom on fail: Discard value

Get Persistence info Dependent item redis.persistence.info_raw

Preprocessing

  • JSON Path: $.Persistence

    ⛔️Custom on fail: Discard value

Get Replication info Dependent item redis.replication.info_raw

Preprocessing

  • JSON Path: $.Replication

    ⛔️Custom on fail: Discard value

Get Server info Dependent item redis.server.info_raw

Preprocessing

  • JSON Path: $.Server

    ⛔️Custom on fail: Discard value

Get Stats info Dependent item redis.stats.info_raw

Preprocessing

  • JSON Path: $.Stats

    ⛔️Custom on fail: Discard value

CPU sys

System CPU consumed by the Redis server

Dependent item redis.cpu.sys

Preprocessing

  • JSON Path: $.used_cpu_sys

CPU sys children

System CPU consumed by the background processes

Dependent item redis.cpu.sys_children

Preprocessing

  • JSON Path: $.used_cpu_sys_children

CPU user

User CPU consumed by the Redis server

Dependent item redis.cpu.user

Preprocessing

  • JSON Path: $.used_cpu_user

CPU user children

User CPU consumed by the background processes

Dependent item redis.cpu.user_children

Preprocessing

  • JSON Path: $.used_cpu_user_children

Blocked clients

The number of connections waiting on a blocking call

Dependent item redis.clients.blocked

Preprocessing

  • JSON Path: $.blocked_clients

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.

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.

Connected clients

The number of connected clients

Dependent item redis.clients.connected

Preprocessing

  • JSON Path: $.connected_clients

Cluster enabled

Indicate Redis cluster is enabled

Dependent item redis.cluster.enabled

Preprocessing

  • JSON Path: $.Cluster.cluster_enabled

Memory used

Total number of bytes allocated by Redis using its allocator

Dependent item redis.memory.used_memory

Preprocessing

  • JSON Path: $.used_memory

Memory used Lua

Amount of memory used by the Lua engine

Dependent item redis.memory.used_memory_lua

Preprocessing

  • JSON Path: $.used_memory_lua

Memory used peak

Peak memory consumed by Redis (in bytes)

Dependent item redis.memory.used_memory_peak

Preprocessing

  • JSON Path: $.used_memory_peak

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

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

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

AOF enabled

Flag indicating AOF logging is activated

Dependent item redis.persistence.aof_enabled

Preprocessing

  • JSON Path: $.aof_enabled

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

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

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

Dump loading

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

Dependent item redis.persistence.loading

Preprocessing

  • JSON Path: $.loading

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

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

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

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

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

Connected slaves

Number of connected slaves

Dependent item redis.replication.connected_slaves

Preprocessing

  • JSON Path: $.connected_slaves

Replication backlog active

Flag indicating replication backlog is active

Dependent item redis.replication.repl_backlog_active

Preprocessing

  • JSON Path: $.repl_backlog_active

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

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

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

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

Master replication offset

Replication offset reported by the master

Dependent item redis.replication.master_repl_offset

Preprocessing

  • JSON Path: $.master_repl_offset

Process id

PID of the server process

Dependent item redis.server.process_id

Preprocessing

  • JSON Path: $.process_id

  • Discard unchanged with heartbeat: 1d

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 version

Version of the Redis server

Dependent item redis.server.redis_version

Preprocessing

  • JSON Path: $.redis_version

  • Discard unchanged with heartbeat: 1d

TCP port

TCP/IP listen port

Dependent item redis.server.tcp_port

Preprocessing

  • JSON Path: $.tcp_port

  • Discard unchanged with heartbeat: 1d

Uptime

Number of seconds since Redis server start

Dependent item redis.server.uptime

Preprocessing

  • JSON Path: $.uptime_in_seconds

Evicted keys

Number of evicted keys due to maxmemory limit

Dependent item redis.stats.evicted_keys

Preprocessing

  • JSON Path: $.evicted_keys

Expired keys

Total number of key expiration events

Dependent item redis.stats.expired_keys

Preprocessing

  • JSON Path: $.expired_keys

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

Instantaneous operations per sec

Number of commands processed per second

Dependent item redis.stats.instantaneous_ops.rate

Preprocessing

  • JSON Path: $.instantaneous_ops_per_sec

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

Keyspace hits

Number of successful lookup of keys in the main dictionary

Dependent item redis.stats.keyspace_hits

Preprocessing

  • JSON Path: $.keyspace_hits

Keyspace misses

Number of failed lookup of keys in the main dictionary

Dependent item redis.stats.keyspace_misses

Preprocessing

  • JSON Path: $.keyspace_misses

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

Migrate cached sockets

The number of sockets open for MIGRATE purposes

Dependent item redis.stats.migrate_cached_sockets

Preprocessing

  • JSON Path: $.migrate_cached_sockets

Pubsub channels

Global number of pub/sub channels with client subscriptions

Dependent item redis.stats.pubsub_channels

Preprocessing

  • JSON Path: $.pubsub_channels

Pubsub patterns

Global number of pub/sub pattern with client subscriptions

Dependent item redis.stats.pubsub_patterns

Preprocessing

  • JSON Path: $.pubsub_patterns

Rejected connections

Number of connections rejected because of maxclients limit

Dependent item redis.stats.rejected_connections

Preprocessing

  • JSON Path: $.rejected_connections

Sync full

The number of full resyncs with replicas

Dependent item redis.stats.sync_full

Preprocessing

  • JSON Path: $.sync_full

Sync partial err

The number of denied partial resync requests

Dependent item redis.stats.sync_partial_err

Preprocessing

  • JSON Path: $.sync_partial_err

Sync partial ok

The number of accepted partial resync requests

Dependent item redis.stats.sync_partial_ok

Preprocessing

  • JSON Path: $.sync_partial_ok

Total commands processed

Total number of commands processed by the server

Dependent item redis.stats.total_commands_processed

Preprocessing

  • JSON Path: $.total_commands_processed

Total connections received

Total number of connections accepted by the server

Dependent item redis.stats.total_connections_received

Preprocessing

  • JSON Path: $.total_connections_received

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

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

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
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:
  • Service is down
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
Service is down last(/Redis by Zabbix agent 2/redis.ping["{$REDIS.CONN.URI}"])=0 Average Manual close: Yes
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
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
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
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
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
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
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
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
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
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
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 will

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 fsync pending jobs in background I/O queue

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

Preprocessing

  • JSON Path: $.aof_pending_bio_fsync

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
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}

Master listening TCP port

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 master

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

Preprocessing

  • JSON Path: $.master_last_io_seconds_ago

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

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

Resident set size memory used by process in bytes.

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

Virtual memory size used by 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
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 that the Redis host has

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

Preprocessing

  • JSON Path: $.total_system_memory

Max memory{#SINGLETON}

Maximum amount of memory allocated to the Redisdb system

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} Dependent item redis.stats.expired_stale_perc[{#SINGLETON}]

Preprocessing

  • JSON Path: $.expired_stale_perc

Expired time cap reached count{#SINGLETON} 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 active the 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
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
Allocator active{#SINGLETON} Dependent item redis.memory.allocator_active[{#SINGLETON}]

Preprocessing

  • JSON Path: $.allocator_active

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

Preprocessing

  • JSON Path: $.allocator_allocated

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

Preprocessing

  • JSON Path: $.allocator_resident

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

Preprocessing

  • JSON Path: $.used_memory_scripts

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

Preprocessing

  • JSON Path: $.number_of_cached_scripts

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

Preprocessing

  • JSON Path: $.allocator_frag_bytes

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

Preprocessing

  • JSON Path: $.allocator_frag_ratio

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

Preprocessing

  • JSON Path: $.allocator_rss_bytes

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

Preprocessing

  • JSON Path: $.allocator_rss_ratio

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

Preprocessing

  • JSON Path: $.rss_overhead_bytes

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

Preprocessing

  • JSON Path: $.rss_overhead_ratio

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

Preprocessing

  • JSON Path: $.mem_fragmentation_bytes

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

Preprocessing

  • JSON Path: $.mem_not_counted_for_evict

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

Preprocessing

  • JSON Path: $.mem_replication_backlog

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

Preprocessing

  • JSON Path: $.mem_clients_normal

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

Preprocessing

  • JSON Path: $.mem_clients_slaves

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

Didn't find what you are looking for?