深入理解 Redis INFO 命令参数：监控服务器性能的必备工具

深碍√TFBOYSˉ_ 2024-03-24 09:12 5阅读 0赞

## 1、前言 ##

Redis 是一个高性能的键值存储系统，已经成为了很多互联网企业的首选。在 Redis 中，通过执行 INFO 命令可以获取到 Redis 实例的各种信息和统计数据，这些数据对于运维和开发人员来说都是非常重要的。

随着 Redis 的广泛应用和深入学习，了解 Redis INFO 命令的参数和输出内容将变得越来越重要。在本文中，我们将详细介绍 Redis INFO 命令的各个参数，包括它们所表示的意义、输出的数据格式以及如何使用这些信息来监控和优化 Redis 实例的性能。

[Redis 的 info 命令参数的官方文档链接 ][Redis _ info _]

## 2、INFO 命令参数 ##

INFO 命令以一种计算机易于解析、人类易于阅读的格式返回有关服务器的信息和统计信息。

可选参数可以用于选择特定的信息部分：

*  server: Redis服务器的通用信息
 *  clients: 客户端连接部分
 *  memory: 与内存消耗相关的信息
 *  persistence: RDB和AOF相关的信息
 *  stats: Redis服务器的一般统计信息
 *  replication: 主/从复制信息
 *  cpu: CPU使用统计信息
 *  commandstats: Redis命令统计信息
 *  latencystats: Redis命令延迟百分位数分布统计信息
 *  sentinel: Redis Sentinel部分（仅适用于Sentinel实例）
 *  cluster: Redis Cluster部分
 *  modules: 模块部分
 *  keyspace: 与数据库相关的统计信息
 *  modules: 模块相关部分
 *  errorstats: Redis错误统计信息

## 3、Spring Boot 项目简单示例 ##

首先，在Spring Boot项目中添加以下依赖项：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

然后，在应用程序配置文件（application.properties或application.yml）中配置Redis连接：

spring.redis.host=127.0.0.1
    spring.redis.port=6379
    spring.redis.password=your_password

接下来，我们可以在应用程序中使用 RedisTemplate 来执行 Redis 命令。以下是一个简单的示例：

@RestController
    @RequestMapping("/redis")
    public class RedisController {
        
    
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        @GetMapping("/info")
        public String getInfo() {
        
            Properties info = (Properties) redisTemplate.execute((RedisCallback<Object>) connection -> connection.info());
            return info.toString();
        }
    
    }

在上面的示例中，我们注入了一个 RedisTemplate 实例，并在 GET 请求处理方法中使用该实例执行 Redis INFO 命令。我们将结果作为 Properties 对象返回，这可以方便地转换为 JSON 字符串或其他格式。

最后，我们可以通过访问 http://localhost:8080/redis/info 来获取 Redis 服务器的信息。

需要注意的是，由于 INFO 命令返回的信息非常详细，因此在生产环境中最好不要使用此方法。相反，应该使用专业的监控工具来监控 Redis 服务器的性能和状态。

## 4、返回值参数说明 ##

请注意，根据 Redis 的版本，某些字段可能已添加或删除。因此，健壮的客户端应用程序应通过跳过未知属性来解析此命令的结果，并优雅地处理缺失字段。

### 4.1、命令及返回信息示例 ###

redis> INFO
    "# Server
    redis_version:7.0.10
    redis_git_sha1:00000000
    redis_git_dirty:0
    redis_build_id:de582ff341d0b85c
    redis_mode:standalone
    os:Linux 5.15.0-1015-aws x86_64
    arch_bits:64
    monotonic_clock:POSIX clock_gettime
    multiplexing_api:epoll
    atomicvar_api:c11-builtin
    gcc_version:10.2.1
    process_id:1
    process_supervised:no
    run_id:9df984d51c0472627f699ca291c42a415c8ea4b9
    tcp_port:6379
    server_time_usec:1679898621742431
    uptime_in_seconds:565125
    uptime_in_days:6
    hz:10
    configured_hz:10
    lru_clock:2177021
    executable:/data/redis-server
    config_file:/etc/redis/redis.conf
    io_threads_active:0
    
    # Clients
    connected_clients:2
    cluster_connections:0
    maxclients:10000
    client_recent_max_input_buffer:20480
    client_recent_max_output_buffer:0
    blocked_clients:0
    tracking_clients:0
    clients_in_timeout_table:0
    
    # Memory
    used_memory:43818096
    used_memory_human:41.79M
    used_memory_rss:50896896
    used_memory_rss_human:48.54M
    used_memory_peak:43831488
    used_memory_peak_human:41.80M
    used_memory_peak_perc:99.97%
    used_memory_overhead:12362920
    used_memory_startup:862912
    used_memory_dataset:31455176
    used_memory_dataset_perc:73.23%
    allocator_allocated:43909712
    allocator_active:44888064
    allocator_resident:48369664
    total_system_memory:16585551872
    total_system_memory_human:15.45G
    used_memory_lua:31744
    used_memory_vm_eval:31744
    used_memory_lua_human:31.00K
    used_memory_scripts_eval:0
    number_of_cached_scripts:0
    number_of_functions:0
    number_of_libraries:0
    used_memory_vm_functions:32768
    used_memory_vm_total:64512
    used_memory_vm_total_human:63.00K
    used_memory_functions:184
    used_memory_scripts:184
    used_memory_scripts_human:184B
    maxmemory:4294967296
    maxmemory_human:4.00G
    maxmemory_policy:allkeys-lru
    allocator_frag_ratio:1.02
    allocator_frag_bytes:978352
    allocator_rss_ratio:1.08
    allocator_rss_bytes:3481600
    rss_overhead_ratio:1.05
    rss_overhead_bytes:2527232
    mem_fragmentation_ratio:1.16
    mem_fragmentation_bytes:7080624
    mem_not_counted_for_evict:0
    mem_replication_backlog:0
    mem_total_replication_buffers:0
    mem_clients_slaves:0
    mem_clients_normal:44544
    mem_cluster_links:0
    mem_aof_buffer:0
    mem_allocator:jemalloc-5.2.1
    active_defrag_running:0
    lazyfree_pending_objects:0
    lazyfreed_objects:0
    
    # Persistence
    loading:0
    async_loading:0
    current_cow_peak:0
    current_cow_size:0
    current_cow_size_age:0
    current_fork_perc:0.00
    current_save_keys_processed:0
    current_save_keys_total:0
    rdb_changes_since_last_save:618133
    rdb_bgsave_in_progress:0
    rdb_last_save_time:1679333496
    rdb_last_bgsave_status:ok
    rdb_last_bgsave_time_sec:-1
    rdb_current_bgsave_time_sec:-1
    rdb_saves:0
    rdb_last_cow_size:0
    rdb_last_load_keys_expired:0
    rdb_last_load_keys_loaded:0
    aof_enabled:0
    aof_rewrite_in_progress:0
    aof_rewrite_scheduled:0
    aof_last_rewrite_time_sec:-1
    aof_current_rewrite_time_sec:-1
    aof_last_bgrewrite_status:ok
    aof_rewrites:0
    aof_rewrites_consecutive_failures:0
    aof_last_write_status:ok
    aof_last_cow_size:0
    module_fork_in_progress:0
    module_fork_last_cow_size:0
    
    # Stats
    total_connections_received:6
    total_commands_processed:784890
    instantaneous_ops_per_sec:6
    total_net_input_bytes:62320959
    total_net_output_bytes:20369725
    total_net_repl_input_bytes:0
    total_net_repl_output_bytes:0
    instantaneous_input_kbps:0.46
    instantaneous_output_kbps:0.04
    instantaneous_input_repl_kbps:0.00
    instantaneous_output_repl_kbps:0.00
    rejected_connections:0
    sync_full:0
    sync_partial_ok:0
    sync_partial_err:0
    expired_keys:18560
    expired_stale_perc:0.06
    expired_time_cap_reached_count:0
    expire_cycle_cpu_milliseconds:34722
    evicted_keys:0
    evicted_clients:0
    total_eviction_exceeded_time:0
    current_eviction_exceeded_time:0
    keyspace_hits:177581
    keyspace_misses:18218
    pubsub_channels:0
    pubsub_patterns:0
    pubsubshard_channels:0
    latest_fork_usec:0
    total_forks:0
    migrate_cached_sockets:0
    slave_expires_tracked_keys:0
    active_defrag_hits:0
    active_defrag_misses:0
    active_defrag_key_hits:0
    active_defrag_key_misses:0
    total_active_defrag_time:0
    current_active_defrag_time:0
    tracking_total_keys:0
    tracking_total_items:0
    tracking_total_prefixes:0
    unexpected_error_replies:0
    total_error_replies:1308
    dump_payload_sanitizations:0
    total_reads_processed:785383
    total_writes_processed:785381
    io_threaded_reads_processed:0
    io_threaded_writes_processed:0
    reply_buffer_shrinks:2054
    reply_buffer_expands:2065
    
    # Replication
    role:master
    connected_slaves:0
    master_failover_state:no-failover
    master_replid:13ad650a73d09fd9d41079bafd2293301778b0e3
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:0
    second_repl_offset:-1
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0
    
    # CPU
    used_cpu_sys:534.161936
    used_cpu_user:902.087929
    used_cpu_sys_children:0.000000
    used_cpu_user_children:0.003575
    used_cpu_sys_main_thread:533.986340
    used_cpu_user_main_thread:901.936420
    
    # Modules
    
    # Errorstats
    errorstat_ERR:count=725
    errorstat_NOPERM:count=477
    errorstat_WRONGTYPE:count=106
    
    # Cluster
    cluster_enabled:0
    
    # Keyspace
    db0:keys=233437,expires=519,avg_ttl=31303011175963
    "
    redis>

### 4.2、server 参数说明 ###

以下是 server 信息部分的所有字段的含义：

*  redis\_version：Redis 服务器的版本号
 *  redis\_git\_sha1：Git SHA1
 *  redis\_git\_dirty：Git dirty 标志
 *  redis\_build\_id：构建 ID
 *  redis\_mode：服务器的模式（“standalone”、“sentinel” 或 “cluster”）
 *  os：Redis 服务器所在的操作系统
 *  arch\_bits：体系结构（32 或 64 位）
 *  multiplexing\_api：Redis 使用的事件循环机制
 *  atomicvar\_api：Redis 使用的 Atomicvar API
 *  gcc\_version：用于编译 Redis 服务器的 GCC 编译器版本
 *  process\_id：服务器进程的 PID
 *  process\_supervised：监控系统（“upstart”、“systemd”、“unknown” 或 “no”）
 *  run\_id：随机值，用于标识 Redis 服务器（用于 Sentinel 和 Cluster）
 *  tcp\_port：TCP/IP 监听端口
 *  server\_time\_usec：基于纪元的系统时间，微秒精度
 *  uptime\_in\_seconds：Redis 服务器启动后的秒数
 *  uptime\_in\_days：同样的值以天为单位表示
 *  hz：服务器的当前频率设置
 *  configured\_hz：服务器的配置频率设置
 *  lru\_clock：每分钟递增的时钟，用于 LRU 管理
 *  executable：服务器可执行文件的路径
 *  config\_file：配置文件的路径
 *  io\_threads\_active：指示 I/O 线程是否处于活动状态的标志
 *  shutdown\_in\_milliseconds：副本在完成关闭序列之前赶上复制的最大时间。此字段仅在关闭期间存在。

### 4.3、clients 参数说明 ###

以下是 clients 信息部分的所有字段的含义：

*  connected\_clients：当前客户端连接数（不包括复制品连接）。
 *  cluster\_connections：集群总线使用的套接字数量的近似值。
 *  maxclients：maxclients 配置指令的值，这是 connected\_clients、connected\_slaves 和 cluster\_connections 的上限。
 *  client\_recent\_max\_input\_buffer：当前所有客户端连接中最大的输入缓冲区大小。
 *  client\_recent\_max\_output\_buffer：当前所有客户端连接中最大的输出缓冲区大小。
 *  blocked\_clients：在阻塞调用（如 BLPOP、BRPOP、BRPOPLPUSH、BLMOVE、BZPOPMIN、BZPOPMAX）中等待的客户端数量。
 *  tracking\_clients：正在被跟踪的客户端数量（CLIENT TRACKING）。
 *  clients\_in\_timeout\_table：客户端超时表中的客户端数量。

### 4.4、memory 参数说明 ###

以下是 memory 信息部分的所有字段的含义：  
以下是内存部分中各字段的含义：

*  used\_memory：Redis分配的字节数，使用其分配器（标准libc、jemalloc或其他分配器，例如tcmalloc）。
 *  used\_memory\_human：上述值的人类可读表示形式。
 *  used\_memory\_rss：操作系统看到的Redis分配的字节数（即驻留集大小）。这是由top（1）和ps（1）等工具报告的数字。
 *  used\_memory\_rss\_human：上述值的人类可读表示形式。
 *  used\_memory\_peak：Redis消耗的最大内存峰值（以字节为单位）。
 *  used\_memory\_peak\_human：上述值的人类可读表示形式。
 *  used\_memory\_peak\_perc：used\_memory\_peak相对于used\_memory的百分比。
 *  used\_memory\_overhead：服务器为管理其内部数据结构分配的所有开销之和。
 *  used\_memory\_startup：Redis在启动时初始消耗的内存量（以字节为单位）。
 *  used\_memory\_dataset：数据集的大小（用于覆盖used\_memory\_overhead）。
 *  used\_memory\_dataset\_perc：used\_memory\_dataset相对于净内存使用量（used\_memory减去used\_memory\_startup）的百分比。
 *  total\_system\_memory：Redis主机拥有的总内存量。
 *  total\_system\_memory\_human：上述值的人类可读表示形式。
 *  used\_memory\_lua：Lua引擎使用的字节数。
 *  used\_memory\_lua\_human：上述值的人类可读表示形式。
 *  used\_memory\_scripts：缓存的Lua脚本使用的字节数。
 *  used\_memory\_scripts\_human：上述值的人类可读表示形式。
 *  maxmemory：maxmemory配置指令的值。
 *  maxmemory\_human：上述值的人类可读表示形式。
 *  maxmemory\_policy：maxmemory-policy配置指令的值。
 *  mem\_fragmentation\_ratio：used\_memory\_rss与used\_memory之间的比率。请注意，这不仅包括碎片，还包括其他进程开销（请参见allocator\_\*指标），以及代码、共享库、堆栈等开销。
 *  mem\_fragmentation\_bytes：used\_memory\_rss与used\_memory之间的差异。请注意，当总碎片字节较低（几兆字节）时，高比率（例如1.5及以上）不表示问题。
 *  allocator\_frag\_ratio：allocator\_active和allocator\_allocated之间的比率。这是真正的（外部）碎片度量标准（不是mem\_fragmentation\_ratio）。
 *  allocator\_frag\_bytes：allocator\_active和allocator\_allocated之间的差异。请参阅关于mem\_fragmentation\_bytes的注释。
 *  allocator\_rss\_ratio：allocator\_resident和allocator\_active之间的比率。这通常表示分配器可以并且很快会释放回OS的页面。
 *  allocator\_rss\_bytes：allocator\_resident和allocator\_active之间的差异。
 *  rss\_overhead\_ratio：used\_memory\_rss（进程RSS）与allocator\_resident之间的比率。这包括不是分配器或堆相关的RSS开销。
 *  rss\_overhead\_bytes：used\_memory\_rss（进程RSS）与allocator\_resident之间的差异。
 *  allocator\_allocated: 分配器分配的总字节数，包括内部碎片。通常与used\_memory相同。
 *  allocator\_active: 分配器活动页面中的总字节数，包括外部碎片。
 *  allocator\_resident: 分配器中居民（RSS）的总字节数，包括可以通过MEMORY PURGE释放给操作系统（或只是等待）的页面。
 *  mem\_not\_counted\_for\_evict: 不计入密钥驱逐的使用内存。这基本上是瞬态副本和AOF缓冲区。
 *  mem\_clients\_slaves: 副本客户端使用的内存 - 从Redis 7.0开始，副本缓冲区与复制后备共享内存，因此当副本不触发内存使用增加时，此字段可能显示为0。
 *  mem\_clients\_normal: 普通客户端使用的内存
 *  mem\_cluster\_links: 在启用集群模式时，与对等体的链接使用的内存。
 *  mem\_aof\_buffer: 用于AOF和AOF重写缓冲区的瞬态内存
 *  mem\_replication\_backlog: 复制后备使用的内存
 *  mem\_total\_replication\_buffers: 用于复制缓冲区的总内存 - 在Redis 7.0中添加。
 *  mem\_allocator: 在编译时选择的内存分配器。
 *  active\_defrag\_running: 当启用主动碎片整理时，这表示碎片整理当前是否活动，并且它打算利用的CPU百分比。
 *  lazyfree\_pending\_objects: 等待释放的对象数量（作为调用UNLINK或带有ASYNC选项的FLUSHDB和FLUSHALL的结果）
 *  lazyfreed\_objects: 已延迟释放的对象数量。

理想情况下，used\_memory\_rss 的值应该只比 used\_memory 略高。当 rss >> used 时，大的差异可能意味着存在（外部）内存碎片，可以通过检查 allocator\_frag\_ratio 和allocator\_frag\_bytes 来评估。当 used >> rss 时，这意味着 Redis 的一部分内存已经被操作系统换出，可能会出现一些显著的延迟。

由于 Redis 无法控制其分配如何映射到内存页，因此高 used\_memory\_rss 通常是内存使用量激增的结果。

当 Redis 释放内存时，内存会被返还给分配器，分配器可能会或可能不会将内存返还给系统。used\_memory 值和操作系统报告的内存消耗之间可能存在差异。这可能是由于 Redis 使用并释放了内存，但尚未将其返还给系统。used\_memory\_peak 值通常有助于检查此点。

有关服务器内存的其他内省信息可以通过参考 MEMORY STATS 命令和 MEMORY DOCTOR 获得。

### 4.5、persistence 参数说明 ###

以下是 persistence 信息部分的所有字段的含义：

*  loading: 表示是否正在进行加载dump文件的标志
 *  async\_loading: 在服务旧数据时异步加载复制数据集。这意味着启用了repl-diskless-load并设置为swapdb。Redis 7.0中添加。
 *  current\_cow\_peak: 当子进程正在运行时，复制写入内存的峰值大小（以字节为单位）
 *  current\_cow\_size: 当子进程正在运行时，复制写入内存的大小（以字节为单位）
 *  current\_cow\_size\_age: current\_cow\_size值的年龄，以秒为单位。
 *  current\_fork\_perc: 当前fork过程的进度百分比。对于AOF和RDB forks，它是当前current\_save\_keys\_processed占current\_save\_keys\_total的百分比。
 *  current\_save\_keys\_processed: 当前保存操作处理的键数
 *  current\_save\_keys\_total: 当前保存操作开始时的键数
 *  rdb\_changes\_since\_last\_save: 上次dump以来更改的次数
 *  rdb\_bgsave\_in\_progress: 表示RDB保存正在进行中的标志
 *  rdb\_last\_save\_time: 上次成功的RDB保存的基于Epoch的时间戳
 *  rdb\_last\_bgsave\_status: 上次RDB保存操作的状态
 *  rdb\_last\_bgsave\_time\_sec: 上次RDB保存操作的持续时间（以秒为单位）
 *  rdb\_current\_bgsave\_time\_sec: 如果有，则表示正在进行中的RDB保存操作的持续时间
 *  rdb\_last\_cow\_size: 上次RDB保存操作期间复制写入内存的大小（以字节为单位）
 *  rdb\_last\_load\_keys\_expired: 在上次RDB加载期间删除的易失性键的数量。Redis 7.0中添加。
 *  rdb\_last\_load\_keys\_loaded: 在上次RDB加载期间加载的键数。Redis 7.0中添加。
 *  aof\_enabled: 表示已激活AOF日志记录的标志
 *  aof\_rewrite\_in\_progress: 表示正在进行AOF重写操作的标志
 *  aof\_rewrite\_scheduled: 表示一旦正在进行的RDB保存操作完成，将安排AOF重写操作的标志。
 *  aof\_last\_rewrite\_time\_sec: 上次AOF重写操作的持续时间（以秒为单位）
 *  aof\_current\_rewrite\_time\_sec: 如果有，则表示正在进行中的AOF重写操作的持续时间
 *  aof\_last\_bgrewrite\_status: 上次AOF重写操作的状态
 *  aof\_last\_write\_status: 上次写入AOF的操作的状态
 *  aof\_last\_cow\_size: 上次AOF重写操作期间复制写入内存的大小（以字节为单位）
 *  module\_fork\_in\_progress: 表示模块fork正在进行中的标志
 *  module\_fork\_last\_cow\_size: 上次模块fork操作期间复制写入内存的大小（以字节为单位）
 *  aof\_rewrites: 自启动以来执行的AOF重写次数
 *  rdb\_saves: 自启动以来执行的RDB快照数

rdb\_changes\_since\_last\_save 指的是自上次调用SAVE或BGSAVE以来在数据集中产生某种更改

如果启用了AOF，将添加以下附加字段：

*  aof\_current\_size：AOF当前文件大小
 *  aof\_base\_size：最新启动或重写时的AOF文件大小
 *  aof\_pending\_rewrite：指示将在当前RDB保存完成后安排AOF重写操作的标志。
 *  aof\_buffer\_length：AOF缓冲区大小
 *  aof\_rewrite\_buffer\_length：AOF重写缓冲区的大小。请注意，此字段已在Redis 7.0中删除。
 *  aof\_pending\_bio\_fsync：后台I / O队列中待处理的fsync作业数
 *  aof\_delayed\_fsync：延迟的fsync计数器

如果正在进行加载操作，则将添加以下附加字段：

*  loading\_start\_time：加载操作开始时的时间戳
 *  loading\_total\_bytes：文件的总大小
 *  loading\_rdb\_used\_mem：文件创建时生成RDB文件的服务器的内存使用情况
 *  loading\_loaded\_bytes：已加载的字节数
 *  loading\_loaded\_perc：以百分比表示的相同值
 *  loading\_eta\_seconds：加载完成的剩余时间（以秒为单位）

### 4.6、stats 参数说明 ###

以下是 stats 信息部分的所有字段的含义：

*  total\_connections\_received：服务器接受的连接总数
 *  total\_commands\_processed：服务器处理的命令总数
 *  instantaneous\_ops\_per\_sec：每秒处理的命令数
 *  total\_net\_input\_bytes：从网络读取的总字节数
 *  total\_net\_output\_bytes：写入网络的总字节数
 *  total\_net\_repl\_input\_bytes：用于复制目的从网络读取的总字节数
 *  total\_net\_repl\_output\_bytes：用于复制目的写入网络的总字节数
 *  instantaneous\_input\_kbps：每秒从网络读取的速率，以 KB/sec 为单位
 *  instantaneous\_output\_kbps：每秒写入网络的速率，以 KB/sec 为单位
 *  instantaneous\_input\_repl\_kbps：每秒为复制目的从网络读取的速率，以 KB/sec 为单位
 *  instantaneous\_output\_repl\_kbps：每秒为复制目的写入网络的速率，以 KB/sec 为单位
 *  rejected\_connections：因 maxclients 限制而被拒绝的连接数
 *  sync\_full：与副本进行完全重新同步的次数
 *  sync\_partial\_ok：接受的部分重新同步请求的次数
 *  sync\_partial\_err：被拒绝的部分重新同步请求的次数
 *  expired\_keys：键过期事件的总数
 *  expired\_stale\_perc：可能过期的键的百分比
 *  expired\_time\_cap\_reached\_count：已停止活动到期周期的次数
 *  expire\_cycle\_cpu\_milliseconds：在活动到期周期上花费的累计时间
 *  evicted\_keys：因 maxmemory 限制而被逐出的键的数量
 *  evicted\_clients：因 maxmemory-clients 限制而被逐出的客户端的数量。在 Redis 7.0 中添加。
 *  total\_eviction\_exceeded\_time：自服务器启动以来，used\_memory 大于 maxmemory 的总时间，以毫秒为单位
 *  current\_eviction\_exceeded\_time：used\_memory 自上次上升到 maxmemory 以来经过的时间，以毫秒为单位
 *  keyspace\_hits：在主字典中查找键成功的次数
 *  keyspace\_misses：在主字典中查找键失败的次数
 *  pubsub\_channels：具有客户端订阅的 pub/sub 频道的全局数量
 *  pubsub\_patterns：具有客户端订阅的 pub/sub 模式的全局数量
 *  pubsubshard\_channels：具有客户端订阅的 pub/sub 分片频道的全局数量。在 Redis 7.0.3 中添加。
 *  latest\_fork\_usec：最新一次 fork 操作的持续时间，以微秒为单位
 *  total\_forks：自服务器启动以来的 fork 操作总数
 *  migrate\_cached\_sockets：为 MIGRATE 目的打开的套接字数
 *  slave\_expires\_tracked\_keys：被跟踪以进行到期处理的键的数量（仅适用于可写副本）
 *  active\_defrag\_hits：由主动碎片整理过程执行的值重定向次数
 *  active\_defrag\_misses: 主动碎片整理进程启动的已中止的值重新分配数量
 *  active\_defrag\_key\_hits: 被主动碎片整理处理的键的数量
 *  active\_defrag\_key\_misses: 被主动碎片整理跳过的键的数量
 *  total\_active\_defrag\_time: 内存碎片化超过限制的总时间（以毫秒为单位）
 *  current\_active\_defrag\_time: 上次内存碎片化超过限制后经过的时间（以毫秒为单位）
 *  tracking\_total\_keys: 服务器正在跟踪的键的数量
 *  tracking\_total\_items: 正在被跟踪的项的数量，即每个键的客户端数量之和
 *  tracking\_total\_prefixes: 服务器前缀表中跟踪的前缀数量（仅适用于广播模式）
 *  unexpected\_error\_replies: 意外错误回复的数量，即 AOF 加载或复制过程中出现的错误类型
 *  total\_error\_replies: 发出的错误回复总数，即拒绝执行命令的数量（命令执行之前的错误）和失败的命令数量（命令执行期间的错误）
 *  dump\_payload\_sanitizations: 转储负载深度完整性验证的总次数（请参阅sanitize-dump-payload配置）。
 *  total\_reads\_processed: 已处理的读事件总数
 *  total\_writes\_processed: 已处理的写事件总数
 *  io\_threaded\_reads\_processed: 主线程和I/O 线程处理的读事件数量
 *  io\_threaded\_writes\_processed: 主线程和I/O 线程处理的写事件数量
 *  acl\_access\_denied\_auth: 鉴权失败的次数
 *  acl\_access\_denied\_cmd: 因命令访问被拒绝而被拒绝执行的命令数量
 *  acl\_access\_denied\_key: 因键访问被拒绝而被拒绝执行的命令数量
 *  acl\_access\_denied\_channel: 因频道访问被拒绝而被拒绝执行的命令数量

### 4.7、replication 参数说明 ###

以下是 replication 信息部分的所有字段的含义：

*  role: 如果实例不是任何主服务器的副本，则值为“master”，如果实例是某个主服务器的副本，则值为“slave”。请注意，副本可以是另一个副本的主服务器（链式复制）。
 *  master\_failover\_state: 进行中故障转移的状态（如果有）。
 *  master\_replid: Redis 服务器的复制ID。
 *  master\_replid2: 用于故障转移后的 PSYNC 的次要复制ID。
 *  master\_repl\_offset: 服务器的当前复制偏移量。
 *  second\_repl\_offset: 接受复制ID的偏移量上限。
 *  repl\_backlog\_active: 表示复制后备日志是否处于活动状态的标志。
 *  repl\_backlog\_size: 复制后备缓冲区的总大小（以字节为单位）。
 *  repl\_backlog\_first\_byte\_offset: 复制后备缓冲区的主偏移量。
 *  repl\_backlog\_histlen: 复制后备缓冲区中数据的大小（以字节为单位）。

如果实例是一个副本，那么会提供这些额外的字段：

*  master\_host：主节点的主机名或 IP 地址
 *  master\_port：主节点的 TCP 端口号
 *  master\_link\_status：连接状态（up/down）
 *  master\_last\_io\_seconds\_ago：与主节点进行最后一次交互的时间（秒数）
 *  master\_sync\_in\_progress：指示主节点正在同步到副本
 *  slave\_read\_repl\_offset：副本实例的读取复制偏移量
 *  slave\_repl\_offset：副本实例的复制偏移量
 *  slave\_priority：作为故障转移候选实例的优先级
 *  slave\_read\_only：标志表示副本是否只读
 *  replica\_announced：标志表示副本是否由 Sentinel 宣布。

如果正在进行SYNC操作，将提供以下附加字段：

*  master\_sync\_total\_bytes: 需要传输的总字节数。当大小未知时（例如使用repl-diskless-sync配置指令时），此值可能为0。
 *  master\_sync\_read\_bytes: 已传输的字节数。
 *  master\_sync\_left\_bytes: 在同步完成之前剩余的字节数（当master\_sync\_total\_bytes为0时可能为负数）。
 *  master\_sync\_perc: master\_sync\_read\_bytes占master\_sync\_total\_bytes的百分比，或者在- master\_sync\_total\_bytes为0时使用loading\_rdb\_used\_mem进行近似计算。
 *  master\_sync\_last\_io\_seconds\_ago: 在SYNC操作期间的最后一次传输I/O之后的秒数。

如果实例是一个副本，以下额外的字段将被提供：

*  master\_host：主服务器的主机名或 IP 地址
 *  master\_port：主服务器的监听 TCP 端口
 *  master\_link\_status：链路状态（上行或下行）
 *  master\_last\_io\_seconds\_ago：距上次与主服务器进行交互的秒数
 *  master\_sync\_in\_progress：指示主服务器正在同步到副本
 *  slave\_read\_repl\_offset：副本实例的读取复制偏移量。
 *  slave\_repl\_offset：副本实例的复制偏移量
 *  slave\_priority：副本作为故障转移候选者的优先级
 *  slave\_read\_only：指示副本是否为只读
 *  replica\_announced：指示 Sentinel 是否已宣告该副本。

### 4.8、cpu 参数说明 ###

以下是 cpu 信息部分的所有字段的含义：

*  used\_cpu\_sys：Redis 服务器消耗的系统 CPU，是进程中所有线程（主线程和后台线程）消耗的系统 CPU 之和。
 *  used\_cpu\_user：Redis 服务器消耗的用户 CPU，是进程中所有线程（主线程和后台线程）消耗的用户 CPU 之和。
 *  used\_cpu\_sys\_children：Redis 后台进程消耗的系统 CPU。
 *  used\_cpu\_user\_children：Redis 后台进程消耗的用户 CPU。
 *  used\_cpu\_sys\_main\_thread：Redis 主线程消耗的系统 CPU。
 *  used\_cpu\_user\_main\_thread：Redis 主线程消耗的用户 CPU。

### 4.9、commandstats 参数说明 ###

commandstats 是一个 Redis INFO 命令输出的一部分，它提供有关 Redis 实例上执行的每种命令的统计信息。这些统计信息包括以下内容：

*  calls：该命令在 Redis 服务器中执行的次数（不包括拒绝的调用）
 *  usec：该命令在 Redis 服务器上消耗的 CPU 时间的总和（以微秒为单位）
 *  usec\_per\_call：该命令每次调用在 Redis 服务器上消耗的平均 CPU 时间（以微秒为单位）
 *  rejected\_calls：在执行该命令之前被 Redis 服务器拒绝的调用次数
 *  failed\_calls：在执行该命令期间发生错误的调用次数

对于每种命令类型，INFO 命令的输出都会添加一个以 cmdstat\_XXX 命名的行，其中 XXX 是命令的名称。例如，以下是关于 INCR 命令的示例输出：

cmdstat_incr:calls=100000,usec=45222,usec_per_call=0.45,rejected_calls=0,failed_calls=0

这表明 INCR 命令已经被调用了 100,000 次，在 Redis 服务器上消耗了 45,222 微秒的 CPU 时间，平均每次调用耗时 0.45 微秒，没有被拒绝的调用和失败的调用。

### 4.10、latencystats 参数说明 ###

latencystats 是 Redis 的一个统计指标，提供了基于命令类型的延迟百分比分布统计信息。默认情况下，导出的延迟百分比是 p50、p99 和 p999。如果需要更改导出的百分比，可以使用 CONFIG SET latency-tracking-info-percentiles “50.0 99.0 99.9” 命令进行更改。

latencystats 需要启用扩展延迟监视功能（默认情况下已启用）。如果需要启用它，可以使用 CONFIG SET latency-tracking yes 命令进行启用。

对于每种命令类型，latencystats 提供以下行：

latency\_percentiles\_usec\_XXX: p<percentile 1>=<percentile 1 value>,p<percentile 2>=<percentile 2 value>,…

其中，XXX 是命令类型的名称，p 表示第 n 个百分位数，其值为 ，以微秒为单位。例如：

latency\_percentiles\_usec\_get: p50=10,p99=20,p999=30,…

这意味着在执行 GET 命令时，50% 的请求的延迟小于 10 微秒，99% 的请求的延迟小于 20 微秒，99.9% 的请求的延迟小于 30 微秒。

### 4.11、errorstats 参数说明 ###

Redis 提供了errorstats 选项，它允许跟踪Redis返回的错误类型以及它们的数量。这些错误基于答复错误前缀，该前缀指出 Redis 返回的错误类型（例如，ERR或WRONGTYPE等）。

使用 INFO 命令获取 Redis 服务器的状态信息时，可以查看到 errorstats 选项的相关信息。对于每个错误类型，都会显示其名称以及出现的次数。

例如，以下是在 Redis 中执行 INFO 命令并查看 errorstats 选项的输出示例：

# Error stats
    errorstat_ERR:count=1000
    errorstat_WRONGTYPE:count=500
    errorstat_READONLY:count=200

在此示例中，Redis 服务器已经返回了 1000 个ERR错误、500 个 WRONGTYP E错误和 200 个 READONLY 错误。这些错误信息可以用于跟踪 Redis 服务器的健康状况，以及检测是否存在特定类型的错误，以便在需要时对 Redis 服务器进行调整和维护。

### 4.12、sentinel 参数说明 ###

sentinel 部分仅适用于 Redis Sentinel 实例。它包括以下字段：

*  sentinel\_masters：此Sentinel实例监视的Redis主服务器数量
 *  sentinel\_tilt：值为1表示此Sentinel处于TILT模式
 *  sentinel\_tilt\_since\_seconds：当前TILT的持续时间（以秒为单位），如果没有TILTed，则为-1。在Redis 7.0.0中添加
 *  sentinel\_running\_scripts：此Sentinel当前正在执行的脚本数量
 *  sentinel\_scripts\_queue\_length：等待执行的用户脚本队列的长度
 *  sentinel\_simulate\_failure\_flags：SENTINEL SIMULATE-FAILURE命令的标志

### 4.13、cluster 参数说明 ###

集群部分当前仅包含一个唯一的字段：

*  cluster\_enabled：指示Redis集群已启用

### 4.14、modules 参数说明 ###

如果模块提供了附加信息，则模块部分包含有关加载的模块的其他信息。此部分属性行的字段部分始终以模块的名称为前缀。

### 4.15、keyspace 参数说明 ###

keyspace 部分提供有关每个数据库的主字典的统计信息。统计信息是键的数量和具有过期时间的键的数量。

对于每个数据库，添加以下行：

dbXXX：keys=XXX，expires=XXX

关于本手册中使用的“slave”一词的说明：从Redis 5开始，如果不是为了向后兼容性，Redis项目不再使用“slave”一词。不幸的是，在此命令中，单词“slave”是协议的一部分，因此只有当此API自然过时时，我们才能删除此类出现。

模块生成的部分：从Redis 6开始，模块可以将它们的信息注入到INFO命令中，即使提供了所有参数，这些也将默认被排除在外（它将包括已加载模块的列表，但不包括它们生成的信息字段）。要获取这些信息，必须使用模块参数或everything。

## 5、历史 ##

从 Redis 7.0.0版本开始：增加了对获取多个部分参数的支持。

## 6、结语 ##

在 Redis 中，INFO 命令提供了大量的系统信息和统计数据，这些信息和数据可以帮助我们更好地了解 Redis 服务器的状态和性能表现，从而更好地优化 Redis 应用程序。在实际的开发和运维过程中，我们可以通过不同的 Redis 客户端（如 Java 客户端、Spring Boot 客户端等）来调用 INFO 命令，从而获取 Redis 服务器的信息和统计数据。同时，我们也可以通过第三方监控工具来实时监控 Redis 服务器的状态和性能表现，以保障 Redis 应用程序的可靠性和高可用性。

#### 本文教程到此结束，祝愿小伙伴们在编程之旅中能够愉快地探索、学习、成长！ ####

[Redis _ info _]: https://redis.io/commands/info