首页 > 数据库> > Zabbix5.0 监控redis

Zabbix5.0 监控redis

2021-07-26 11:02:12 作者：互联网

Blog：博客园个人

使用zabbix 5.0自带模板和zabbix-agent2监控redis。

前提

redis服务器需要部署zabbix-agent2。

配置监控

模板官方地址：Source of README.md - Zabbix - ZABBIX GIT

zabbix-agent2已经集成了redis的监控插件，并且5.0版本也自带了相关模板，因此配置比较简单，直接关联即可。但如果redis配置了密码，需要针对模板做一下调整。

在模板中新增宏：

注意：如果需要监控非本地Redis，则需要修改模板中的{$REDIS.CONN.URI}。

同时在监控项中修改相关指标：

然后看下效果：

监控指标

Group	Name	Description	Type	Key and additional info
Redis	Redis: Ping		ZABBIX_PASSIVE	redis.ping["{$REDIS.CONN.URI}"]Preprocessing:- DISCARD_UNCHANGED_HEARTBEAT: `10m`
Redis	Redis: Slowlog entries per second		ZABBIX_PASSIVE	redis.slowlog.count["{$REDIS.CONN.URI}"]Preprocessing:- CHANGE_PER_SECOND
Redis	Redis: CPU sys	System CPU consumed by the Redis server	DEPENDENT	redis.cpu.sysPreprocessing:- JSONPATH: `$.CPU.used_cpu_sys`
Redis	Redis: CPU sys children	System CPU consumed by the background processes	DEPENDENT	redis.cpu.sys_childrenPreprocessing:- JSONPATH: `$.CPU.used_cpu_sys_children`
Redis	Redis: CPU user	User CPU consumed by the Redis server	DEPENDENT	redis.cpu.userPreprocessing:- JSONPATH: `$.CPU.used_cpu_user`
Redis	Redis: CPU user children	User CPU consumed by the background processes	DEPENDENT	redis.cpu.user_childrenPreprocessing:- JSONPATH: `$.CPU.used_cpu_user_children`
Redis	Redis: Blocked clients	The number of connections waiting on a blocking call	DEPENDENT	redis.clients.blockedPreprocessing:- JSONPATH: `$.Clients.blocked_clients`
Redis	Redis: Max input buffer	The biggest input buffer among current client connections	DEPENDENT	redis.clients.max_input_bufferPreprocessing:- JAVASCRIPT: `Text is too long. Please see the template.`
Redis	Redis: Max output buffer	The biggest output buffer among current client connections	DEPENDENT	redis.clients.max_output_bufferPreprocessing:- JAVASCRIPT: `Text is too long. Please see the template.`
Redis	Redis: Connected clients	The number of connected clients	DEPENDENT	redis.clients.connectedPreprocessing:- JSONPATH: `$.Clients.connected_clients`
Redis	Redis: Cluster enabled	Indicate Redis cluster is enabled	DEPENDENT	redis.cluster.enabledPreprocessing:- JSONPATH: `$.Cluster.cluster_enabled`
Redis	Redis: Memory used	Total number of bytes allocated by Redis using its allocator	DEPENDENT	redis.memory.used_memoryPreprocessing:- JSONPATH: `$.Memory.used_memory`
Redis	Redis: Memory used Lua	Amount of memory used by the Lua engine	DEPENDENT	redis.memory.used_memory_luaPreprocessing:- JSONPATH: `$.Memory.used_memory_lua`
Redis	Redis: Memory used peak	Peak memory consumed by Redis (in bytes)	DEPENDENT	redis.memory.used_memory_peakPreprocessing:- JSONPATH: `$.Memory.used_memory_peak`
Redis	Redis: Memory used RSS	Number of bytes that Redis allocated as seen by the operating system	DEPENDENT	redis.memory.used_memory_rssPreprocessing:- JSONPATH: `$.Memory.used_memory_rss`
Redis	Redis: Memory fragmentation ratio	This ratio is an indication of memory mapping efficiency:— Value over 1.0 indicate that memory fragmentation is very likely. Consider restarting the Redis server so the operating system can recover fragmented memory, especially with a ratio over 1.5.— Value under 1.0 indicate that Redis likely has insufficient memory available. Consider optimizing memory usage or adding more RAM.Note: If your peak memory usage is much higher than your current memory usage, the memory fragmentation ratio may be unreliable.https://redis.io/topics/memory-optimization	DEPENDENT	redis.memory.fragmentation_ratioPreprocessing:- JSONPATH: `$.Memory.mem_fragmentation_ratio`
Redis	Redis: AOF current rewrite time sec	Duration of the on-going AOF rewrite operation if any	DEPENDENT	redis.persistence.aof_current_rewrite_time_secPreprocessing:- JSONPATH: `$.Persistence.aof_current_rewrite_time_sec`
Redis	Redis: AOF enabled	Flag indicating AOF logging is activated	DEPENDENT	redis.persistence.aof_enabledPreprocessing:- JSONPATH: `$.Persistence.aof_enabled`
Redis	Redis: AOF last bgrewrite status	Status of the last AOF rewrite operation	DEPENDENT	redis.persistence.aof_last_bgrewrite_statusPreprocessing:- JSONPATH: `$.Persistence.aof_last_bgrewrite_status`- BOOL_TO_DECIMAL
Redis	Redis: AOF last rewrite time sec	Duration of the last AOF rewrite	DEPENDENT	redis.persistence.aof_last_rewrite_time_secPreprocessing:- JSONPATH: `$.Persistence.aof_last_rewrite_time_sec`
Redis	Redis: AOF last write status	Status of the last write operation to the AOF	DEPENDENT	redis.persistence.aof_last_write_statusPreprocessing:- JSONPATH: `$.Persistence.aof_last_write_status`- BOOL_TO_DECIMAL
Redis	Redis: AOF rewrite in progress	Flag indicating a AOF rewrite operation is on-going	DEPENDENT	redis.persistence.aof_rewrite_in_progressPreprocessing:- JSONPATH: `$.Persistence.aof_rewrite_in_progress`
Redis	Redis: AOF rewrite scheduled	Flag indicating an AOF rewrite operation will be scheduled once the on-going RDB save is complete	DEPENDENT	redis.persistence.aof_rewrite_scheduledPreprocessing:- JSONPATH: `$.Persistence.aof_rewrite_scheduled`
Redis	Redis: Dump loading	Flag indicating if the load of a dump file is on-going	DEPENDENT	redis.persistence.loadingPreprocessing:- JSONPATH: `$.Persistence.loading`
Redis	Redis: RDB bgsave in progress	"1" if bgsave is in progress and "0" otherwise	DEPENDENT	redis.persistence.rdb_bgsave_in_progressPreprocessing:- JSONPATH: `$.Persistence.rdb_bgsave_in_progress`
Redis	Redis: RDB changes since last save	Number of changes since the last background save	DEPENDENT	redis.persistence.rdb_changes_since_last_savePreprocessing:- JSONPATH: `$.Persistence.rdb_changes_since_last_save`
Redis	Redis: RDB current bgsave time sec	Duration of the on-going RDB save operation if any	DEPENDENT	redis.persistence.rdb_current_bgsave_time_secPreprocessing:- JSONPATH: `$.Persistence.rdb_current_bgsave_time_sec`
Redis	Redis: RDB last bgsave status	Status of the last RDB save operation	DEPENDENT	redis.persistence.rdb_last_bgsave_statusPreprocessing:- JSONPATH: `$.Persistence.rdb_last_bgsave_status`- BOOL_TO_DECIMAL
Redis	Redis: RDB last bgsave time sec	Duration of the last bg_save operation	DEPENDENT	redis.persistence.rdb_last_bgsave_time_secPreprocessing:- JSONPATH: `$.Persistence.rdb_last_bgsave_time_sec`
Redis	Redis: RDB last save time	Epoch-based timestamp of last successful RDB save	DEPENDENT	redis.persistence.rdb_last_save_timePreprocessing:- JSONPATH: `$.Persistence.rdb_last_save_time`
Redis	Redis: Connected slaves	Number of connected slaves	DEPENDENT	redis.replication.connected_slavesPreprocessing:- JSONPATH: `$.Replication.connected_slaves`
Redis	Redis: Replication backlog active	Flag indicating replication backlog is active	DEPENDENT	redis.replication.repl_backlog_activePreprocessing:- JSONPATH: `$.Replication.repl_backlog_active`
Redis	Redis: Replication backlog first byte offset	The master offset of the replication backlog buffer	DEPENDENT	redis.replication.repl_backlog_first_byte_offsetPreprocessing:- JSONPATH: `$.Replication.repl_backlog_first_byte_offset`
Redis	Redis: Replication backlog history length	Amount of data in the backlog sync buffer	DEPENDENT	redis.replication.repl_backlog_histlenPreprocessing:- JSONPATH: `$.Replication.repl_backlog_histlen`
Redis	Redis: Replication backlog size	Total size in bytes of the replication backlog buffer	DEPENDENT	redis.replication.repl_backlog_sizePreprocessing:- JSONPATH: `$.Replication.repl_backlog_size`
Redis	Redis: Replication role	Value is "master" if the instance is replica of no one, or "slave" if the instance is a replica of some master instance. Note that a replica can be master of another replica (chained replication).	DEPENDENT	redis.replication.rolePreprocessing:- JSONPATH: `$.Replication.role`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Master replication offset	Replication offset reported by the master	DEPENDENT	redis.replication.master_repl_offsetPreprocessing:- JSONPATH: `$.Replication.master_repl_offset`
Redis	Redis: Process id	PID of the server process	DEPENDENT	redis.server.process_idPreprocessing:- JSONPATH: `$.Server.process_id`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Redis mode	The server's mode ("standalone", "sentinel" or "cluster")	DEPENDENT	redis.server.redis_modePreprocessing:- JSONPATH: `$.Server.redis_mode`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Redis version	Version of the Redis server	DEPENDENT	redis.server.redis_versionPreprocessing:- JSONPATH: `$.Server.redis_version`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: TCP port	TCP/IP listen port	DEPENDENT	redis.server.tcp_portPreprocessing:- JSONPATH: `$.Server.tcp_port`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Uptime	Number of seconds since Redis server start	DEPENDENT	redis.server.uptimePreprocessing:- JSONPATH: `$.Server.uptime_in_seconds`
Redis	Redis: Evicted keys	Number of evicted keys due to maxmemory limit	DEPENDENT	redis.stats.evicted_keysPreprocessing:- JSONPATH: `$.Stats.evicted_keys`
Redis	Redis: Expired keys	Total number of key expiration events	DEPENDENT	redis.stats.expired_keysPreprocessing:- JSONPATH: `$.Stats.expired_keys`
Redis	Redis: Instantaneous input bytes per second	The network's read rate per second in KB/sec	DEPENDENT	redis.stats.instantaneous_input.ratePreprocessing:- JSONPATH: `$.Stats.instantaneous_input_kbps`- MULTIPLIER: `1024`
Redis	Redis: Instantaneous operations per sec	Number of commands processed per second	DEPENDENT	redis.stats.instantaneous_ops.ratePreprocessing:- JSONPATH: `$.Stats.instantaneous_ops_per_sec`
Redis	Redis: Instantaneous output bytes per second	The network's write rate per second in KB/sec	DEPENDENT	redis.stats.instantaneous_output.ratePreprocessing:- JSONPATH: `$.Stats.instantaneous_output_kbps`- MULTIPLIER: `1024`
Redis	Redis: Keyspace hits	Number of successful lookup of keys in the main dictionary	DEPENDENT	redis.stats.keyspace_hitsPreprocessing:- JSONPATH: `$.Stats.keyspace_hits`
Redis	Redis: Keyspace misses	Number of failed lookup of keys in the main dictionary	DEPENDENT	redis.stats.keyspace_missesPreprocessing:- JSONPATH: `$.Stats.keyspace_misses`
Redis	Redis: Latest fork usec	Duration of the latest fork operation in microseconds	DEPENDENT	redis.stats.latest_fork_usecPreprocessing:- JSONPATH: `$.Stats.latest_fork_usec`- MULTIPLIER: `1.0E-5`
Redis	Redis: Migrate cached sockets	The number of sockets open for MIGRATE purposes	DEPENDENT	redis.stats.migrate_cached_socketsPreprocessing:- JSONPATH: `$.Stats.migrate_cached_sockets`
Redis	Redis: Pubsub channels	Global number of pub/sub channels with client subscriptions	DEPENDENT	redis.stats.pubsub_channelsPreprocessing:- JSONPATH: `$.Stats.pubsub_channels`
Redis	Redis: Pubsub patterns	Global number of pub/sub pattern with client subscriptions	DEPENDENT	redis.stats.pubsub_patternsPreprocessing:- JSONPATH: `$.Stats.pubsub_patterns`
Redis	Redis: Rejected connections	Number of connections rejected because of maxclients limit	DEPENDENT	redis.stats.rejected_connectionsPreprocessing:- JSONPATH: `$.Stats.rejected_connections`
Redis	Redis: Sync full	The number of full resyncs with replicas	DEPENDENT	redis.stats.sync_fullPreprocessing:- JSONPATH: `$.Stats.sync_full`
Redis	Redis: Sync partial err	The number of denied partial resync requests	DEPENDENT	redis.stats.sync_partial_errPreprocessing:- JSONPATH: `$.Stats.sync_partial_err`
Redis	Redis: Sync partial ok	The number of accepted partial resync requests	DEPENDENT	redis.stats.sync_partial_okPreprocessing:- JSONPATH: `$.Stats.sync_partial_ok`
Redis	Redis: Total commands processed	Total number of commands processed by the server	DEPENDENT	redis.stats.total_commands_processedPreprocessing:- JSONPATH: `$.Stats.total_commands_processed`
Redis	Redis: Total connections received	Total number of connections accepted by the server	DEPENDENT	redis.stats.total_connections_receivedPreprocessing:- JSONPATH: `$.Stats.total_connections_received`
Redis	Redis: Total net input bytes	The total number of bytes read from the network	DEPENDENT	redis.stats.total_net_input_bytesPreprocessing:- JSONPATH: `$.Stats.total_net_input_bytes`
Redis	Redis: Total net output bytes	The total number of bytes written to the network	DEPENDENT	redis.stats.total_net_output_bytesPreprocessing:- JSONPATH: `$.Stats.total_net_output_bytes`
Redis	Redis: Max clients	Max number of connected clients at the same time.Once the limit is reached Redis will close all the new connections sending an error "max number of clients reached".	DEPENDENT	redis.config.maxclientsPreprocessing:- JSONPATH: `$.maxclients`- DISCARD_UNCHANGED_HEARTBEAT: `30m`
Redis	DB {#DB}: Average TTL	Average TTL	DEPENDENT	redis.db.avg_ttl["{#DB}"]Preprocessing:- JSONPATH: `$.Keyspace["{#DB}"].avg_ttl`- MULTIPLIER: `0.001`
Redis	DB {#DB}: Expires	Number of keys with an expiration	DEPENDENT	redis.db.expires["{#DB}"]Preprocessing:- JSONPATH: `$.Keyspace["{#DB}"].expires`
Redis	DB {#DB}: Keys	Total number of keys	DEPENDENT	redis.db.keys["{#DB}"]Preprocessing:- JSONPATH: `$.Keyspace["{#DB}"].keys`
Redis	Redis: AOF current size{#SINGLETON}	AOF current file size	DEPENDENT	redis.persistence.aof_current_size[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_current_size`
Redis	Redis: AOF base size{#SINGLETON}	AOF file size on latest startup or rewrite	DEPENDENT	redis.persistence.aof_base_size[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_base_size`
Redis	Redis: AOF pending rewrite{#SINGLETON}	Flag indicating an AOF rewrite operation will	DEPENDENT	redis.persistence.aof_pending_rewrite[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_pending_rewrite`
Redis	Redis: AOF buffer length{#SINGLETON}	Size of the AOF buffer	DEPENDENT	redis.persistence.aof_buffer_length[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_buffer_length`
Redis	Redis: AOF rewrite buffer length{#SINGLETON}	Size of the AOF rewrite buffer	DEPENDENT	redis.persistence.aof_rewrite_buffer_length[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_rewrite_buffer_length`
Redis	Redis: AOF pending background I/O fsync{#SINGLETON}	Number of fsync pending jobs in background I/O queue	DEPENDENT	redis.persistence.aof_pending_bio_fsync[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_pending_bio_fsync`
Redis	Redis: AOF delayed fsync{#SINGLETON}	Delayed fsync counter	DEPENDENT	redis.persistence.aof_delayed_fsync[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_delayed_fsync`
Redis	Redis: Master host{#SINGLETON}	Host or IP address of the master	DEPENDENT	redis.replication.master_host[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.master_host`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Master port{#SINGLETON}	Master listening TCP port	DEPENDENT	redis.replication.master_port[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.master_port`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Master link status{#SINGLETON}	Status of the link (up/down)	DEPENDENT	redis.replication.master_link_status[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.master_link_status`- BOOL_TO_DECIMAL
Redis	Redis: Master last I/O seconds ago{#SINGLETON}	Number of seconds since the last interaction with master	DEPENDENT	redis.replication.master_last_io_seconds_ago[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.master_last_io_seconds_ago`
Redis	Redis: Master sync in progress{#SINGLETON}	Indicate the master is syncing to the replica	DEPENDENT	redis.replication.master_sync_in_progress[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.master_sync_in_progress`
Redis	Redis: Slave replication offset{#SINGLETON}	The replication offset of the replica instance	DEPENDENT	redis.replication.slave_repl_offset[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.slave_repl_offset`
Redis	Redis: Slave priority{#SINGLETON}	The priority of the instance as a candidate for failover	DEPENDENT	redis.replication.slave_priority[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.slave_priority`
Redis	Redis: Slave priority{#SINGLETON}	Flag indicating if the replica is read-only	DEPENDENT	redis.replication.slave_read_only[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.slave_read_only`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis slave {#SLAVE_IP}:{#SLAVE_PORT}: Replication lag in bytes	Replication lag in bytes	DEPENDENT	redis.replication.lag_bytes["{#SLAVE_IP}:{#SLAVE_PORT}"]Preprocessing:- JAVASCRIPT: `Text is too long. Please see the template.`
Redis	Redis: Number of processes running	-	ZABBIX_PASSIVE	proc.num["{$REDIS.PROCESS_NAME}{#SINGLETON}"]
Redis	Redis: Memory usage (rss)	Resident set size memory used by process in bytes.	ZABBIX_PASSIVE	proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,rss]
Redis	Redis: Memory usage (vsize)	Virtual memory size used by process in bytes.	ZABBIX_PASSIVE	proc.mem["{$REDIS.PROCESS_NAME}{#SINGLETON}",,,,vsize]
Redis	Redis: CPU utilization	Process CPU utilization percentage.	ZABBIX_PASSIVE	proc.cpu.util["{$REDIS.PROCESS_NAME}{#SINGLETON}"]
Redis	Redis: Executable path{#SINGLETON}	The path to the server's executable	DEPENDENT	redis.server.executable[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Server.executable`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Memory used peak %{#SINGLETON}	The percentage of used_memory_peak out of used_memory	DEPENDENT	redis.memory.used_memory_peak_perc[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_peak_perc`- REGEX: `(.+)% \1`
Redis	Redis: Memory used overhead{#SINGLETON}	The sum in bytes of all overheads that the server allocated for managing its internal data structures	DEPENDENT	redis.memory.used_memory_overhead[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_overhead`
Redis	Redis: Memory used startup{#SINGLETON}	Initial amount of memory consumed by Redis at startup in bytes	DEPENDENT	redis.memory.used_memory_startup[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_startup`
Redis	Redis: Memory used dataset{#SINGLETON}	The size in bytes of the dataset	DEPENDENT	redis.memory.used_memory_dataset[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_dataset`
Redis	Redis: Memory used dataset %{#SINGLETON}	The percentage of used_memory_dataset out of the net memory usage (used_memory minus used_memory_startup)	DEPENDENT	redis.memory.used_memory_dataset_perc[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_dataset_perc`- REGEX: `(.+)% \1`
Redis	Redis: Total system memory{#SINGLETON}	The total amount of memory that the Redis host has	DEPENDENT	redis.memory.total_system_memory[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.total_system_memory`
Redis	Redis: Max memory{#SINGLETON}	Maximum amount of memory allocated to the Redisdb system	DEPENDENT	redis.memory.maxmemory[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.maxmemory`
Redis	Redis: Max memory policy{#SINGLETON}	The value of the maxmemory-policy configuration directive	DEPENDENT	redis.memory.maxmemory_policy[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.maxmemory_policy`- DISCARD_UNCHANGED_HEARTBEAT: `1d`
Redis	Redis: Active defrag running{#SINGLETON}	Flag indicating if active defragmentation is active	DEPENDENT	redis.memory.active_defrag_running[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.active_defrag_running`
Redis	Redis: Lazyfree pending objects{#SINGLETON}	The number of objects waiting to be freed (as a result of calling UNLINK, or FLUSHDB and FLUSHALL with the ASYNC option)	DEPENDENT	redis.memory.lazyfree_pending_objects[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.lazyfree_pending_objects`
Redis	Redis: RDB last CoW size{#SINGLETON}	The size in bytes of copy-on-write allocations during the last RDB save operation	DEPENDENT	redis.persistence.rdb_last_cow_size[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.rdb_last_cow_size`
Redis	Redis: AOF last CoW size{#SINGLETON}	The size in bytes of copy-on-write allocations during the last AOF rewrite operation	DEPENDENT	redis.persistence.aof_last_cow_size[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Persistence.aof_last_cow_size`
Redis	Redis: Expired stale %{#SINGLETON}		DEPENDENT	redis.stats.expired_stale_perc[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.expired_stale_perc`
Redis	Redis: Expired time cap reached count{#SINGLETON}		DEPENDENT	redis.stats.expired_time_cap_reached_count[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.expired_time_cap_reached_count`
Redis	Redis: Slave expires tracked keys{#SINGLETON}	The number of keys tracked for expiry purposes (applicable only to writable replicas)	DEPENDENT	redis.stats.slave_expires_tracked_keys[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.slave_expires_tracked_keys`
Redis	Redis: Active defrag hits{#SINGLETON}	Number of value reallocations performed by active the defragmentation process	DEPENDENT	redis.stats.active_defrag_hits[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.active_defrag_hits`
Redis	Redis: Active defrag misses{#SINGLETON}	Number of aborted value reallocations started by the active defragmentation process	DEPENDENT	redis.stats.active_defrag_misses[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.active_defrag_misses`
Redis	Redis: Active defrag key hits{#SINGLETON}	Number of keys that were actively defragmented	DEPENDENT	redis.stats.active_defrag_key_hits[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.active_defrag_key_hits`
Redis	Redis: Active defrag key misses{#SINGLETON}	Number of keys that were skipped by the active defragmentation process	DEPENDENT	redis.stats.active_defrag_key_misses[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Stats.active_defrag_key_misses`
Redis	Redis: Replication second offset{#SINGLETON}	Offset up to which replication IDs are accepted	DEPENDENT	redis.replication.second_repl_offset[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Replication.second_repl_offset`
Redis	Redis: Allocator active{#SINGLETON}		DEPENDENT	redis.memory.allocator_active[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_active`
Redis	Redis: Allocator allocated{#SINGLETON}		DEPENDENT	redis.memory.allocator_allocated[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_allocated`
Redis	Redis: Allocator resident{#SINGLETON}		DEPENDENT	redis.memory.allocator_resident[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_resident`
Redis	Redis: Memory used scripts{#SINGLETON}		DEPENDENT	redis.memory.used_memory_scripts[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.used_memory_scripts`
Redis	Redis: Memory number of cached scripts{#SINGLETON}		DEPENDENT	redis.memory.number_of_cached_scripts[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.number_of_cached_scripts`
Redis	Redis: Allocator fragmentation bytes{#SINGLETON}		DEPENDENT	redis.memory.allocator_frag_bytes[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_frag_bytes`
Redis	Redis: Allocator fragmentation ratio{#SINGLETON}		DEPENDENT	redis.memory.allocator_frag_ratio[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_frag_ratio`
Redis	Redis: Allocator RSS bytes{#SINGLETON}		DEPENDENT	redis.memory.allocator_rss_bytes[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_rss_bytes`
Redis	Redis: Allocator RSS ratio{#SINGLETON}		DEPENDENT	redis.memory.allocator_rss_ratio[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.allocator_rss_ratio`
Redis	Redis: Memory RSS overhead bytes{#SINGLETON}		DEPENDENT	redis.memory.rss_overhead_bytes[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.rss_overhead_bytes`
Redis	Redis: Memory RSS overhead ratio{#SINGLETON}		DEPENDENT	redis.memory.rss_overhead_ratio[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.rss_overhead_ratio`
Redis	Redis: Memory fragmentation bytes{#SINGLETON}		DEPENDENT	redis.memory.fragmentation_bytes[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_fragmentation_bytes`
Redis	Redis: Memory not counted for evict{#SINGLETON}		DEPENDENT	redis.memory.not_counted_for_evict[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_not_counted_for_evict`
Redis	Redis: Memory replication backlog{#SINGLETON}		DEPENDENT	redis.memory.replication_backlog[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_replication_backlog`
Redis	Redis: Memory clients normal{#SINGLETON}		DEPENDENT	redis.memory.mem_clients_normal[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_clients_normal`
Redis	Redis: Memory clients slaves{#SINGLETON}		DEPENDENT	redis.memory.mem_clients_slaves[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_clients_slaves`
Redis	Redis: Memory AOF buffer{#SINGLETON}	Size of the AOF buffer	DEPENDENT	redis.memory.mem_aof_buffer[{#SINGLETON}]Preprocessing:- JSONPATH: `$.Memory.mem_aof_buffer`
Zabbix_raw_items	Redis: Get info		ZABBIX_PASSIVE	redis.info["{$REDIS.CONN.URI}"]
Zabbix_raw_items	Redis: Get config		ZABBIX_PASSIVE	redis.config["{$REDIS.CONN.URI}"]Preprocessing:- DISCARD_UNCHANGED_HEARTBEAT: `1h`

标签：SINGLETON,Zabbix5.0,DEPENDENT,redis,Redis,JSONPATH,监控,memory
来源： https://www.cnblogs.com/Rohn/p/15060486.html