Zabbix5.0 监控redis

2022年01月14日 阅读数:1
这篇文章主要向大家介绍Zabbix5.0 监控redis,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

Blog:博客园 我的git

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

前提

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

配置监控

模板官方地址:Source of README.md - Zabbix - ZABBIX GITapp

zabbix-agent2已经集成了redis的监控插件,而且5.0版本也自带了相关模板,所以配置比较简单,直接关联便可。但若是redis配置了密码,须要针对模板作一下调整。socket

在模板中新增宏:tcp

image-20210726104648939

注意:若是须要监控非本地Redis,则须要修改模板中的{$REDIS.CONN.URI}ide

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

image-20210726103720240

而后看下效果:spa

image-20210726103837668

监控指标

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