Pika 需要哪些必要的 Metrics 指标？

[yaoyinnan]

待讨论的问题

为了更精确反馈 RocksDB 调优需求，我们发起本次讨论：Pika 需要哪些必要的 RocksDB 指标？

目前梳理了 Pika 现有的 metrics 指标，主要包括 Pika 本身的指标和 RocksDB 的指标。
情况如下：

1. Pika 的 RocksDB 指标仅有 2 则，memtable 和 SST 的内存，不足以反馈 RocksDB 情况。
2. Pika 本身的指标不包含 Redis 命令的情况，如命令执行时间。

资料概览

本文中根据下列资料，提取了部分指标的情况，如需详细了解，请阅读原文。

1. RocksDB 调优指南
   1. 原文：https://github.com/EighteenZi/rocksdb_wiki/blob/master/RocksDB-Tuning-Guide.md
   2. 译文（From henshui）：https://wanghenshui.github.io/rocksdb-doc-cn/doc/RocksDB-Tuning-Guide.html
2. RocksDB DB::Properties 中的属性详解
3. Grafana 监控指标说明 —— RocksDB & ToplingDB 部分
   1. ToplingDB 对 RocksDB 增加了很多可观测性的指标，不确定部分指标原生 RocksDB 是否能够透出。
4. Grafana 监控指标说明 —— Todis 部分

Pika 现有 metrics 获取方式

Info 命令获取 metrics

通过执行 INFO 命令可以获取到全部 metrics：

127.0.0.1:9221> info [section]

#主库：
# Server
pika_version:2.3.0 -------------------------------------------- pika 版本信息
pika_git_sha:3668a2807a3d047ea43656b58a2130c1566eeb65 --------- git的sha值
pika_build_compile_date: Nov 14 2017 -------------------------- pika的编译日期
os:Linux 2.6.32-2.0.0.8-6 x86_64 ------------------------------ 操作系统信息
arch_bits:64 -------------------------------------------------- 操作系统位数
process_id:12969 ---------------------------------------------- pika pid信息
tcp_port:9001 ------------------------------------------------- pika 端口信息
thread_num:12 ------------------------------------------------- pika 线程数量
sync_thread_num:6 --------------------------------------------- sync线程数量
uptime_in_seconds:3074 ---------------------------------------- pika 运行时间（秒）
uptime_in_days:0 ---------------------------------------------- pika 运行时间（天）
config_file:/data1/pika9001/pika9001.conf --------------------- pika conf文件位置
server_id:1 --------------------------------------------------- pika的server id

# Data
db_size:770439 ------------------------------------------------ db的大小(Byte)
db_size_human:0M ---------------------------------------------- 人类可读的db大小(M)
compression:snappy -------------------------------------------- 压缩方式
used_memory:4248 ---------------------------------------------- 使用的内存大小(Byte)
used_memory_human:0M ------------------------------------------ 人类可读的使用的内存大小(M)
db_memtable_usage:4120 ---------------------------------------- memtable的使用量(Byte)
db_tablereader_usage:128 -------------------------------------- tablereader的使用量(Byte)

# Log
log_size:110174 ----------------------------------------------- binlog的大小(Byte)
log_size_human:0M --------------------------------------------- 人类可读的binlog大小(M)
safety_purge:none --------------------------------------------- 目前可以安全删除的文件名
expire_logs_days:7 -------------------------------------------- 设置binlog过期天数
expire_logs_nums:10 ------------------------------------------- 设置binlog过期数量
binlog_offset:0 388 ------------------------------------------- binlog偏移量(文件号，偏移量)
 
# Clients
connected_clients:2 ------------------------------------------- 当前连接数
 
# Stats
total_connections_received:18 --------------------------------- 总连接次数统计
instantaneous_ops_per_sec:1 ----------------------------------- 当前qps
total_commands_processed:633 ---------------------------------- 请求总计
is_bgsaving:No, , 0 ------------------------------------------- pika 备份信息：是否在备份,备份名称，备份
is_scaning_keyspace:No ---------------------------------------- 是否在执行scan操作
is_compact:No ------------------------------------------------- 是否在执行数据压缩操作
compact_cron: ------------------------------------------------- 定时compact(format: start-end/ratio, eg. 02-04/60)
compact_interval: --------------------------------------------- compact的间隔(format: interval/ratio, eg. 6/60)

# CPU
used_cpu_sys:48.52 -------------------------------------------- Pika进程系统CPU占用时间
used_cpu_user:73.10 ------------------------------------------- Pika进程用户CPU占用时间
used_cpu_sys_children:0.05 ------------------------------------ Pika子进程系统CPU占用时间
used_cpu_user_children:0.05 ----------------------------------- Pika子进程用户CPU占用时间
 
# Replication(MASTER)
role:master --------------------------------------------------- 本实例角色
connected_slaves:1 -------------------------------------------- 当前从库数量
slave0:ip=192.168.1.1,port=57765,state=online,sid=2,lag=0 ----- lag：当前主从binlog相差的字节数（byte），如果有多个从库则依次展示
 
#从库（区别仅在于同步信息的展示）：
# Replication(SLAVE)
role:slave ---------------------------------------------------- 本实例角色
master_host:192.168.1.2 --------------------------------------- 主库IP
master_port:9001 ---------------------------------------------- 主库端口
master_link_status:up ----------------------------------------- 当前同步状态
slave_read_only:1 --------------------------------------------- 从库是否readonly
repl_state: connected ----------------------------------------- 从库同步连接的当前状态
 
# Keyspace（key数量展示，按照数据类型分类展示，默认不更新，仅在执行info keyspace 1的时候刷新该信息）
# Time:2016-04-22 17:08:33 ------------------------------------ 上一次统计的时间
db0 Strings_keys=100004, expires=0, invaild_keys=0
db0 Hashes_keys=2, expires=0, invaild_keys=0
db0 Lists_keys=0, expires=0, invaild_keys=0
db0 Zsets_keys=1, expires=0, invaild_keys=0
db0 Sets_keys=0, expires=0, invaild_keys=0
# keys：当前有效KEY的数量，等同于redis的keys 
# expires：keys中带有expire属性的key的数量，等同于Redis 
# invalid_keys：pika独有，指已经失效（标记删除），但还未被rocksdb彻底物理删除的key，虽然这些key不再会被访问到，但会占用一定磁盘空间，如果发现较大可以通过执行compact来彻底清理

# DoubleMaster(MASTER)
role:master --------------------------------------------------- 双主角色
the peer-master host: ----------------------------------------- 双主对端IP
the peer-master port:0 ---------------------------------------- 双主对端Port
the peer-master server_id:0 ----------------------------------- 双主对端server id
double_master_mode: False ------------------------------------- 是否配置双主模式
repl_state: 0 ------------------------------------------------- 双主连接状态
double_master_recv_info: filenum 0 offset 0 ------------------- 从对端接受的Binlog偏移量

Exporter 获取 Pika Info

pika_exporter 通过 Pika Info 命令获取统计信息，再根据 metrics 定义的字段，解析出所需的 Metrics。如 pika_exporter/exporter/metrics/data.go 中定义了 pika_exporter 需要获取的 RocksDB 的 Metrics：

package metrics

func init() {
    Register(collectDataMetrics)
}

var collectDataMetrics = map[string]MetricConfig{
    "db_size": {
        Parser: &normalParser{},
        MetricMeta: &MetaData{
            Name:      "db_size",
            Help:      "pika serve instance total db data size in bytes",
            Type:      metricTypeGauge,
            Labels:    []string{LabelNameAddr, LabelNameAlias, "compression"},
            ValueName: "db_size",
        },
    },
    "used_memory": {
        Parser: &normalParser{},
        MetricMeta: &MetaData{
            Name:      "used_memory",
            Help:      "pika serve instance total used memory size in bytes",
            Type:      metricTypeGauge,
            Labels:    []string{LabelNameAddr, LabelNameAlias},
            ValueName: "used_memory",
        },
    },
    "db_memtable_usage": {
        Parser: &normalParser{},
        MetricMeta: &MetaData{
            Name:      "db_memtable_usage",
            Help:      "pika serve instance memtable total used memory size in bytes",
            Type:      metricTypeGauge,
            Labels:    []string{LabelNameAddr, LabelNameAlias},
            ValueName: "db_memtable_usage",
        },
    },
    "db_tablereader_usage": {
        Parser: &normalParser{},
        MetricMeta: &MetaData{
            Name:      "db_tablereader_usage",
            Help:      "pika serve instance tablereader total used memory size in bytes",
            Type:      metricTypeGauge,
            Labels:    []string{LabelNameAddr, LabelNameAlias},
            ValueName: "db_tablereader_usage",
        },
    },
    "db_fatal": {
        Parser: &normalParser{},
        MetricMeta: &MetaData{
            Name:      "db_fatal",
            Help:      "pika serve instance tablereader total errors ",
            Type:      metricTypeGauge,
            Labels:    []string{LabelNameAddr, LabelNameAlias},
            ValueName: "db_fatal",
        },
    },
}

RocksDB 指标

Properties

RocksDB 中的 DB 类中定义了一个结构体 Properties，里面是许多 RocksDB 的属性。具体代码在 db.h 中。结构体 Properties 中的每个成员都对应一个 rocksdb 属性，我们可以通过 GetProperty() 或 GetMapProperty() 等方法来获取其中的内容。
结合 RocksDB 源码对 Properties 的描述，参考 RocksDB -- DB::Properties 中的属性详解 一文整理了所有 Properties 的参数和含义。内容如下：

序号	Properties	指标	含义
1	kNumFilesAtLevelPrefix	rocksdb.num-files-at-level	返回字符串，包含 Level 处的文件数量，其中是 Level 编号的ASCII表示（例如，"0"）
2	kCompressionRatioAtLevelPrefix	rocksdb.compression-ratio-at-level	返回字符串，包含 Level 处数据的压缩比率，其中是 Level 编号的ASCII表示（例如，"0"）。这里，压缩比率定义为未压缩数据大小/压缩文件大小。如果 Level 没有打开的文件，则返回"-1.0"。
3	kStats	rocksdb.stats	返回一个多行字符串，包含kCFStats描述的数据，后跟kDBStats描述的数据。
4	kSSTables	rocksdb.sstables	返回一个多行字符串，汇总当前SST文件的信息。
5	kCFStats	rocksdb.cfstats	以"map"属性形式返回来自"rocksdb.cfstats-no-file-histogram"和"rocksdb.cf-file-histogram"的原始数据。
6	kCFStatsNoFileHistogram	rocksdb.cfstats-no-file-histogram	返回一个多行字符串，包含数据库生命周期内（"L"表示）和最近检索间隔内（"Sum"和"Int"表示）的每个 Level 的一般列族统计信息。
7	kCFFileHistogram	rocksdb.cf-file-histogram	打印每个 Level 的文件读取次数以及单个请求的延迟直方图。
8	kDBStats	rocksdb.dbstats	作为字符串属性，返回一个多行字符串，包含数据库的总体统计信息，既有累积统计（涵盖数据库生命周期），也有间隔统计（自上次检索kDBStats以来的数据）。作为map属性，只返回累积统计信息，不更新间隔统计信息的基准。
9	kLevelStats	rocksdb.levelstats	返回一个多行字符串，包含每个 Level 的文件数量和每个 Level 的总大小（MB）。
10	kBlockCacheEntryStats	rocksdb.block-cache-entry-stats	返回描述块缓存使用情况的多行字符串或map。
11	kNumImmutableMemTable	rocksdb.num-immutable-mem-table	返回尚未刷盘的不可变 memtable 的数量。
12	kNumImmutableMemTableFlushed	rocksdb.num-immutable-mem-table-flushed	返回已经刷盘的不可变 memtable 的数量。
13	kMemTableFlushPending	rocksdb.mem-table-flush-pending	如果存在 memtable 刷盘挂起，则返回1；否则返回0。
14	kNumRunningFlushes	rocksdb.num-running-flushes	返回当前正在运行的 flush 操作的数量。
15	kCompactionPending	rocksdb.compaction-pending	如果至少有一个 compaction 操作处于挂起状态，则返回 1；否则返回 0。
16	kNumRunningCompactions	rocksdb.num-running-compactions	返回当前正在运行的 compaction 操作的数量。
17	kBackgroundErrors	rocksdb.background-errors	返回累积的后台错误数。
18	kCurSizeActiveMemTable	rocksdb.cur-size-active-mem-table	返回活动 memtable 的近似大小（字节）。
19	kCurSizeAllMemTables	rocksdb.cur-size-all-mem-tables	返回全部 memtabke 总的大概大小（字节）。包含当前活跃的 memtable，以及未 flush 的不可变 memtable。
20	kSizeAllMemTables	rocksdb.size-all-mem-tables	返回全部 memtabke 总的大概大小（字节）。包含当前活跃的 memtable、未 flush 的不可变 memtable，以及 pinned 的不可变 memtable。（pinned：已落盘，但是为了提供读取缓存服务，所以依旧保存在内存中）
21	kNumEntriesActiveMemTable	rocksdb.num-entries-active-mem-table	返回活动 memtable 中的总条目数。
22	kNumEntriesImmMemTables	rocksdb.num-entries-imm-mem-tables	返回未刷盘的不可变 memtable 中的总条目数。
23	kNumDeletesActiveMemTable	rocksdb.num-deletes-active-mem-table	返回活动 memtable 中的删除条目数。
24	kNumDeletesImmMemTables	rocksdb.num-deletes-imm-mem-tables	返回未刷盘的不可变 memtable 中的删除条目数。
25	kEstimateNumKeys	rocksdb.estimate-num-keys	返回活动和未刷盘的不可变 memtable 及存储中的估计总键数。
26	kEstimateTableReadersMem	rocksdb.estimate-table-readers-mem	返回用于读取 SST 表的估计内存使用量，不包括块缓存中使用的内存（如过滤器和索引块）。
27	kIsFileDeletionsEnabled	rocksdb.is-file-deletions-enabled	如果启用了删除过时文件，则返回 0；否则返回非零值。
28	kNumSnapshots	rocksdb.num-snapshots	返回数据库中未释放的快照数。
29	kOldestSnapshotTime	rocksdb.oldest-snapshot-time	返回表示最旧未释放快照的 UNIX 时间戳的数字。
30	kOldestSnapshotSequence	rocksdb.oldest-snapshot-sequence	返回表示最旧未释放快照的序列号。
31	kNumLiveVersions	rocksdb.num-live-versions	返回活动版本的数量。Version 是一个内部数据结构。有关详细信息，请参见 version_set.h。更多的活动版本通常意味着有更多的 SST 文件被迭代器或未完成的 compaction 操作所持有，无法被删除。
32	kCurrentSuperVersionNumber	rocksdb.current-super-version-number	返回当前 LSM 版本的编号。它是一个 uint64_t 整数，在 LSM 树发生任何更改后递增。该编号在重新启动数据库后不会保留。在重新启动数据库后，它将从 0 开始。
33	kEstimateLiveDataSize	rocksdb.estimate-live-data-size	返回活动数据的估计大小（以字节为单位）。对于 BlobDB，它还包括版本的 blob 文件中的实际生存字节数。
34	kMinLogNumberToKeep	rocksdb.min-log-number-to-keep	返回应保留的日志文件的最小日志编号。
35	kMinObsoleteSstNumberToKeep	rocksdb.min-obsolete-sst-number-to-keep	返回应保留的过时 SST 文件的最小文件编号。如果所有过时文件都可以删除，则将返回 uint64_t 的最大值。
36	kTotalSstFilesSize	rocksdb.total-sst-files-size	返回所有 SST 文件的总大小（字节）。注意：如果文件过多，可能会减慢在线查询的速度。
37	kLiveSstFilesSize	rocksdb.live-sst-files-size	返回属于最新 LSM 树的所有 SST 文件的总大小（字节）。
38	kLiveSstFilesSizeAtTemperature	rocksdb.live_sst_files_size_at_temperature	返回指定文件温度下的 SST 文件的总大小（字节）。
39	kBaseLevel	rocksdb.base-level	返回 L0 数据将被 compact 到的 Level 数。
40	kEstimatePendingCompactionBytes	rocksdb.estimate-pending-compaction-bytes	返回重写所有 Level 以使其大小低于目标大小所需的估计总字节数。对于非基于 Level 的 compaction，此项无效。
41	kAggregatedTableProperties	rocksdb.aggregated-table-properties	返回目标列族的聚合表属性的字符串或映射表示。仅包括在聚合中有意义的属性。
42	kAggregatedTablePropertiesAtLevel	rocksdb.aggregated-table-properties-at-level	与前面的属性相同，但只返回目标列族指定 Level "N" 的聚合表属性。
43	kActualDelayedWriteRate	rocksdb.actual-delayed-write-rate	返回当前实际延迟写入速率。0 表示没有延迟。
44	kIsWriteStopped	rocksdb.is-write-stopped	如果写入已停止，则返回 1。
45	kIsWriteStalled	rocksdb.is-write-stalled	如果写入已停滞，则返回 1。
46	kEstimateOldestKeyTime	rocksdb.estimate-oldest-key-time	返回数据库中最旧键的时间戳的估计值。目前仅对 FIFO compaction 可用，要求 compaction_options_fifo.allow_compaction = false。
47	kBlockCacheCapacity	rocksdb.block-cache-capacity	返回块缓存的容量。
48	kBlockCacheUsage	rocksdb.block-cache-usage	返回块缓存中条目所占用的内存大小。
49	kBlockCachePinnedUsage	rocksdb.block-cache-pinned-usage	返回被固定的条目在内存中所占用的大小。
50	kOptionsStatistics	rocksdb.options-statistics	返回选项统计信息的多行字符串表示。
51	kNumBlobFiles	rocksdb.num-blob-files	返回当前版本中 blob 文件的数量。
52	kBlobStats	rocksdb.blob-stats	返回所有 blob 文件的总数和大小，以及当前版本中 blob 文件中的垃圾总量（字节）。
53	kTotalBlobFileSize	rocksdb.total-blob-file-size	返回所有版本中所有 blob 文件的总大小。
54	kLiveBlobFileSize	rocksdb.live-blob-file-size	返回当前版本中所有 blob 文件的总大小。

statistics

statistics —— 把这个设置给rocksdb::CreateDBStatistics()。任何时候，通过调用options.statistics.ToString()，你可以得到一个人类可读的Rocksdb统计信息。
stats_dump_period_sec ——我们每 stats_dump_period_sec 秒就会把统计信息导出到日志文件。默认为600，意味着每10分钟导出一次。你可以在应用里调用 db->GetProperty(“rocksdb.stats”) 得到相同的数据。

每db->GetProperty(“rocksdb.stats”)，会在日志文件里找到这样的数据：

** Compaction Stats **
Level Files  Size(MB) Score Read(GB)  Rn(GB) Rnp1(GB) Write(GB) Wnew(GB) Moved(GB) W-Amp Rd(MB/s) Wr(MB/s) Comp(sec) Comp(cnt) Avg(sec) Stall(sec) Stall(cnt) Avg(ms)     KeyIn   KeyDrop
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
L0      2/0        15   0.5     0.0     0.0      0.0      32.8     32.8       0.0   0.0      0.0     23.0    1457      4346    0.335       0.00          0    0.00             0        0
L1     22/0       125   1.0   163.7    32.8    130.9     165.5     34.6       0.0   5.1     25.6     25.9    6549      1086    6.031       0.00          0    0.00    1287667342        0
L2    227/0      1276   1.0   262.7    34.4    228.4     262.7     34.3       0.1   7.6     26.0     26.0   10344      4137    2.500       0.00          0    0.00    1023585700        0
L3   1634/0     12794   1.0   259.7    31.7    228.1     254.1     26.1       1.5   8.0     20.8     20.4   12787      3758    3.403       0.00          0    0.00    1128138363        0
L4   1819/0     15132   0.1     3.9     2.0      2.0       3.6      1.6      13.1   1.8     20.1     18.4     201       206    0.974       0.00          0    0.00      91486994        0
Sum  3704/0     29342   0.0   690.1   100.8    589.3     718.7    129.4      14.8  21.9     22.5     23.5   31338     13533    2.316       0.00          0    0.00    3530878399        0
Int     0/0         0   0.0     2.1     0.3      1.8       2.2      0.4       0.0  24.3     24.0     24.9      91        42    2.164       0.00          0    0.00      11718977        0
Flush(GB): accumulative 32.786, interval 0.091
Stalls(secs): 0.000 level0_slowdown, 0.000 level0_numfiles, 0.000 memtable_compaction, 0.000 leveln_slowdown_soft, 0.000 leveln_slowdown_hard
Stalls(count): 0 level0_slowdown, 0 level0_numfiles, 0 memtable_compaction, 0 leveln_slowdown_soft, 0 leveln_slowdown_hard

** DB Stats **
Uptime(secs): 128748.3 total, 300.1 interval
Cumulative writes: 1288457363 writes, 14173030838 keys, 357293118 batches, 3.6 writes per batch, 3055.92 GB user ingest, stall micros: 7067721262
Cumulative WAL: 1251702527 writes, 357293117 syncs, 3.50 writes per sync, 3055.92 GB written
Interval writes: 3621943 writes, 39841373 keys, 1013611 batches, 3.6 writes per batch, 8797.4 MB user ingest, stall micros: 112418835
Interval WAL: 3511027 writes, 1013611 syncs, 3.46 writes per sync, 8.59 MB written

Pika 现有 RocksDB 指标

pika/src/pika_admin.cc：

void InfoCmd::InfoData(std::string& info) {
    std::stringstream tmp_stream;
    std::stringstream db_fatal_msg_stream;

    int64_t db_size = pstd::Du(g_pika_conf->db_path());
    tmp_stream << "# Data"
        << "\r\n";
    tmp_stream << "db_size:" << db_size << "\r\n";
    tmp_stream << "db_size_human:" << (db_size >> 20) << "M\r\n";
    int64_t log_size = pstd::Du(g_pika_conf->log_path());
    tmp_stream << "log_size:" << log_size << "\r\n";
    tmp_stream << "log_size_human:" << (log_size >> 20) << "M\r\n";
    tmp_stream << "compression:" << g_pika_conf->compression() << "\r\n";

    // rocksdb related memory usage
    std::map<std::string, uint64_t> type_result;
    uint64_t total_background_errors = 0;
    uint64_t total_memtable_usage = 0, memtable_usage = 0;
    uint64_t total_table_reader_usage = 0, table_reader_usage = 0;
    std::shared_lock table_rwl(g_pika_server->tables_rw_);
    for (const auto& table_item : g_pika_server->tables_) {
        std::shared_lock partition_rwl(table_item.second->partitions_rw_);
        for (const auto& patition_item : table_item.second->partitions_) {
            type_result.clear();
            memtable_usage = table_reader_usage = 0;
            patition_item.second->DbRWLockReader();
            patition_item.second->db()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_MEMTABLE, &memtable_usage);
            patition_item.second->db()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_TABLE_READER, &table_reader_usage);
            patition_item.second->db()->GetUsage(storage::PROPERTY_TYPE_ROCKSDB_BACKGROUND_ERRORS, &type_result);
            patition_item.second->DbRWUnLock();
            total_memtable_usage += memtable_usage;
            total_table_reader_usage += table_reader_usage;
            for (const auto& item : type_result) {
                if (item.second != 0) {
                    db_fatal_msg_stream << (total_background_errors != 0 ? "," : "");
                    db_fatal_msg_stream << patition_item.second->GetPartitionName() << "/" << item.first;
                    total_background_errors += item.second;
                }
            }
        }
    }

  tmp_stream << "used_memory:" << (total_memtable_usage + total_table_reader_usage) << "\r\n";
  tmp_stream << "used_memory_human:" << ((total_memtable_usage + total_table_reader_usage) >> 20) << "M\r\n";
  tmp_stream << "db_memtable_usage:" << total_memtable_usage << "\r\n";
  tmp_stream << "db_tablereader_usage:" << total_table_reader_usage << "\r\n";
  tmp_stream << "db_fatal:" << (total_background_errors != 0 ? "1" : "0") << "\r\n";
  tmp_stream << "db_fatal_msg:" << (total_background_errors != 0 ? db_fatal_msg_stream.str() : "nullptr") << "\r\n";

  info.append(tmp_stream.str());
  return;
}

序号	Pika 指标	RocksDB 中对应的指标	计算规则	含义
1	db_memtable_usage	rocksdb.cur-size-all-mem-tables	sum("rocksdb.cur-size-all-mem-tables")	活动且未刷盘的不可变 MemTable 的近似总大小（字节）。
2	db_tablereader_usage	rocksdb.estimate-table-readers-mem	sum("rocksdb.estimate-table-readers-mem")	用于读取 SST 表的估计内存使用量，不包括 block cache 中使用的内存（例如 filter 和 index blocks）。
3	used_memory	rocksdb.cur-size-all-mem-tablesrocksdb.estimate-table-readers-mem	sum("rocksdb.cur-size-all-mem-tables") + sum("rocksdb.estimate-table-readers-mem")	1、2 值的和。
4	used_memory_human	rocksdb.cur-size-all-mem-tablesrocksdb.estimate-table-readers-mem	sum("rocksdb.cur-size-all-mem-tables") + sum("rocksdb.estimate-table-readers-mem") >> 20	1、2 值的和的人类可读值。
5	db_fatal	rocksdb.background-errors	item.second	累积的后台错误数。
6	db_fatal_msg	rocksdb.background-errors	item.first	累计的后台错误信息。

参考资料

RocksDB & ToplingDB 监控指标

原文：Grafana 监控指标说明 —— RocksDB & ToplingDB 部分

1. engine DB Properties

1.1. common

监控项	含义
engine:num_immutable_mem_table	尚未被 flush 的不可变 memtables 的数量
engine:num_immutable_mem_table_flushed	已经 flush 完成的不可变 memtables 的数量
engine:num_running_flushes	正在运行的 flush 数量
engine:num_running_compactions	正在运行的 compactions 数量
engine:cur_size_active_mem_table	当前活跃的 memtable 的大概大小（字节）
engine:cur_size_all_mem_tables	当前活跃的 memtable 和暂未 flush 的不可变 memtable 的总的大概大小（字节）
engine:size_all_mem_tables	所有 memtable 的总大小（字节），包含活跃的 memtable、未 flush 的不可变 memtable 和 pinned 的不可变的 memtable
engine:num_entries_active_mem_table	当前活跃的 memtable 中的条目数量
engine:num_entries_imm_mem_tables	没有 flush 的不可变 memtable 中的条目数量
engine:num_deletes_active_mem_table	当前活跃的 memtable 中的删除的条目数量
engine:num_deletes_imm_mem_tables	在尚未 flush 的不可变 memtable 中的删除的条目数量
engine:estimate_num_keys	估计的在活跃的 memtable、未 flush 的不可变 memtable 和存储介质中的 key 的数量
engine:estimate_table_readers_mem	读 SST 时使用的内存的大概大小，不包括块缓存（如 filter 和 index 块）
engine:estimate_live_data_size	返回以字节为单位的活动数据量的估计值。对于BlobDB，它还在 version 的 blob 文件中包含活动字节的确切值。
engine:estimate_pending_compaction_bytes	估计的压缩需要重写的字节总数，以使所有级别减小到低于目标大小。除基于级别的压缩外，对其他压缩无效。
engine:is_file_deletions_enabled	如果允许删除废弃的文件，其值为 0，否则为非零值。
engine:background_errors	后台错误的总数
engine:num_live_versions	当前版本的数量。' Version '是一个内部数据结构。详情请参阅 version_set.h。更多的当前版本通常意味着更多的SST文件被迭代器或未完成的压缩删除。
engine:total_sst_files_size	所有 SST 文件的总大小（字节）
engine:live_sst_files_size	属于最新 LSM 树的所有 SST 文件的总大小（字节）。
engine:base_level	L0 的数据将被压缩至的 level 数
engine:num_snapshots	未释放的快照数
engine:oldest_snapshot_time	代表最旧的未释放的快照的 unix 时间戳的数字
engine:oldest_snapshot_sequence	代表最旧的未释放的快照的序列数
engine:num_files_at_level	第 N 层的文件数
engine:compression_ratio_at_level	第 N 层的数据压缩率（数据压缩率=未压缩的数据大小/压缩后的数据大小，值若为 -1.0 表示该层没有打开的文件）
engine:actual_delayed_write_rate	当前实际的延迟写速率，0 表示不延迟。

1.2. cfstat

监控项	含义
compaction.L.AvgSec	L 平均每次 Compact 耗时
compaction.L.CompCount	L Compact 累计的次数
compaction.L.CompMergeCPU	L compaction 中占用的 CPU 时间，单位秒
compaction.L.CompSec	L Compact 累计耗时，单位秒
compaction.L.CompactedFiles	L 已完成 compact 的文件数
compaction.L.KeyDrop	L compact 中删除的 key 数量
compaction.L.KeyIn	L compaction 过程中比较的记录数量
compaction.L.MovedGB	L compaction 过程中，移动到 level n+1 的字节数。
compaction.L.NumFiles	L 的全部的 sst 文件数
compaction.L.RblobGB	L compaction 从 blob 文件中读取的数据大小，单位 GB。
compaction.L.ReadGB	L 读取的大小，单位 GB
compaction.L.ReadMBps	L 的读取速率，单位 MBps
compaction.L.RnGB	L 进行 compact 时，读当前层文件的大小，单位 GB
compaction.L.Rnp1GB	L 进行 compact 时，读下一层文件的大小，单位 GB
compaction.L.Score	L 的分数，分数越高越优先 compact
compaction.L.SizeBytes	L SST 总大小，单位字节
compaction.L.WblobGB	L compaction 期间写入 blob 文件的大小，单位 GB。
compaction.L.WnewGB	L Wnp1 - Rnp1
compaction.L.WriteAmp	（写入 level<N+1>的总字节）/（从 level 读取的总字节）
compaction.L.WriteGB	L compaction 期间写入表文件的大小，单位 GB。
compaction.L.WriteMBps	compaction 中的数据写入速率
io_stalls.level0_numfiles	由于 level0_stop_writes_trigger 导致的 io stop 次数
io_stalls.level0_numfiles_with_compaction	由于 level0_stop_writes_trigger 导致的 compaction 中的 io stop 次数
io_stalls.level0_slowdown	由于 level0_slowdown_writes_trigger 导致的 io stall 次数
io_stalls.level0_slowdown_with_compaction	由于 level0_slowdown_writes_trigger 导致的 compaction 中的 io stall 次数
io_stalls.memtable_compaction	由于所有的 memtable 都满了，flush 进程没跟上导致的 io stop 次数。
io_stalls.memtable_slowdown	由于所有的 memtable 都满了，flush 进程没跟上导致的 io stall 次数。
io_stalls.slowdown_for_pending_compaction_bytes	compaction 中填充字节时 slowdown 的次数
io_stalls.stop_for_pending_compaction_bytes	compaction 中填充字节时 stop 的次数
io_stalls.total_slowdown	发生 slowdown 的总次数

1.3. level

监控项	含义
data_size	数据大小（压缩后的）
index_size	索引大小（压缩后的）
num_data_blocks	数据块的数量
num_deletions	删除的条目数量
num_entries	现存的条目数量
raw_key_size	原始的 key 大小（即压缩前的）
raw_value_size	原始的 value 大小（即压缩前的）

2. engine statistic

2.1. histogram

2.1.1. compaction

监控项	含义
engine:compaction:outfile:sync:micros	compact中outfile->Sync操作耗时统计
engine:compaction:times:cpu_micros	compact操作消耗cpu时间统计，每个单核会相加
engine:compaction:times:micros	compact操作耗时
engine:subcompaction:setup:times:micros	GenSubcompactionBoundaries执行耗时
engine:memtable:compaction:count	未发现调用
engine:db:flush:micros	flush 操作持续的时间，单位 μs
engine:dcompaction:input:raw:bytes	dcompaction 中输入的 kv 原始数据大小
engine:dcompaction:input:zip:bytes	dcompaction 中输入的磁盘上的数据大小
engine:dcompaction:output:file:raw:size	dcompaction 中每个文件的原始 kv 数据大小
engine:dcompaction:output:file:zip:size	dcompaction 中每个文件在磁盘上的大小
engine:lcompaction:input:raw:bytes	lcompaction 中输入的 kv 原始数据大小
engine:lcompaction:input:zip:bytes	lcompaction 中输入的磁盘上的数据大小
engine:lcompaction:output:file:raw:size	lcompaction 中每个文件的原始 kv 数据大小
engine:lcompaction:output:file:zip:size	lcompaction 中每个文件在磁盘上的大小
engine:numfiles:in:singlecompaction	单个 compaction 的输入文件数量
engine:num:subcompactions:scheduled	已经设定好边界的、准备压缩的 sub-compactions 的数量

2.1.2. common

监控项	含义
engine:bytes:per:read	Get() 方法读到的 value 的大小
engine:bytes:per:write	Write() 方法写入的 value 的大小
engine:bytes:per:multiget	MultiGet() 方法读到的所有 value 的总大小
engine:cond:wait:nanos	等待 db 的 condition 的时间，单位 ns
engine:hard:rate:limit:delay:count	未发现调用
engine:l0:slowdown:count	未发现调用
engine:num:files:stall:count	未发现调用
engine:soft:rate:limit:delay:count	未发现调用
engine:db:get:micros	Get() 方法的耗时，单位 μs
engine:db:multiget:micros	MultiGet() 方法的耗时，单位 μs
engine:db:seek:micros	DBIter 类（Iterator 类的派生类）的 Seek() 方法的耗时，单位 μs
engine:db:write:micros	Write() 方法的耗时，单位 μs
engine:db:write:stall	延迟写方法 DelayWrite() 的耗时，包含延迟时间，单位 μs
engine:error:handler:autoresume:retry:count	可恢复的后台 IO 错误的自动恢复尝试次数
engine:manifest:file:sync:micros	manifest 文件 sync 的时间，单位 μs
engine:memtab:construct:nanos	构建一个新的 memtable 的时间，单位 ns
engine:memtab:write:kv:nanos	在 memetable 写入 kv 的时间，单位 ns
engine:mutex:wait:nanos	等待 db 的 mutex 的时间，单位 ns
engine:table:open:io:micros	构建 table reader 时，打开 table 过程中 io 的时间，单位 μs
engine:table:sync:micros	table 的 sync 时间，单位 μs
engine:wal:file:sync:micros	wal 的 sync 时间，单位 μs
engine:write:wal:nanos	写 wal 的时间，单位 ns
engine:num:sst:read:per:level	MultiGet() 在每个 level 读取的 sst 文件数
engine:number:per:multiget	每次 MultiGet() 读取的 key 数量
engine:sst:batch:size	MultiGet() 中在单个 sst 文件中查找的 key 的数量，包含了有墓碑的 key 等
engine:sst:read:micros	Get() 或 MultiGet() 读 sst 的时间，不包含 Get() 延迟读的延迟时间，单位 μs
engine:switch:wal:nanos	切换 wal 文件的时间，单位 ns

2.2. ticker

2.2.1. simple

监控项	含义
engine:bloom:filter:useful	在 block_based_table 中读取时，使用 bloom filter 过滤掉的 key 数目
engine:bloom:filter:full:positive	在 block_based_table 中读取时，使用 bloom filter 过滤后留下的 key 数目
engine:bloom:filter:full:true:positive	在 block_based_table 中读取时，使用 bloom filter 过滤后留下的 ，并且真实存在的 key 数目
engine:bloom:filter:micros	未发现调用
engine:memtable:hit	Get() 或 MultiGet() 在 memtable 中找到 key 的次数
engine:memtable:miss	Get() 或 MultiGet() 在 memtable 中未找到 key 的次数
engine:l0:hit	Get() 或 MultiGet() 在 L0 找到 key 的次数
engine:l1:hit	Get() 或 MultiGet() 在 L1 找到 key 的次数
engine:l2andup:hit	Get() 或 MultiGet() 在 L2 及以上 找到 key 的次数
engine:compaction: key:drop:new	compaction 中用被更新的值覆盖原来值的旧 key 的数量
engine:compaction: key:drop:obsolete	compaction 中的废弃的 key 的数量
engine:compaction: key:drop:range_del	compaction 中由范围墓碑覆盖的 key 的数量
engine:compaction: key:drop:user	compaction 中由用户 compaction 方法删除的 key 的数量
engine:compaction:range_del:drop:obsolete	compaction 中范围删除的 key 数量
engine:compaction:optimized:del:drop:obsolete	由于文件间隙优化，在底层之前删除过时的内容的数量。
engine:compaction:cancelled	因为没有足够的空间而取消的 compaction 次数
engine:number:keys:written	通过 Put() 和 Write() 调用写入数据库的 key 数量
engine:number:keys:read	Get() 的 key 的数量
engine:number:keys:updated	原地更新了 value 的 key 的数量（如果启用了原地更新）
engine:bytes:read	DB::Get() 读取的未压缩字节数，可以来自 memtables、cache 或 table文件
engine:number:db:seek	DBIter::Seek() 的调用次数
engine:number:db:next	DBIter::Next() 的调用次数
engine:number:db:prev	DBIter::Prev() 的调用次数
engine:number:db:seek:found	返回了数据的 DBIter::Seek() 的调用次数
engine:number:db:next:found	返回了数据的 DBIter::Next() 的调用次数
engine:number:db:prev:found	返回了数据的 DBIter::Prev() 的调用次数
engine:db:iter:bytes:read	通过 Iterator 读到的未压缩的字节数，key 和 value 都算
engine:no:file:closes	未发现调用
engine:no:file:opens	构建 table reader 和 bolb file reader 时，打开的文件数
engine:no:file:errors	构建 table reader 和 bolb file reader 时，打开失败的文件数
engine:l0:slowdown:micros	已弃用
engine:memtable:compaction:micros	已弃用
engine:l0:num:files:stall:micros	已弃用
engine:stall:micros	延迟写的延迟时间。
engine:db:cond:wait:nanos	等待 db 的 condition 的时间，单位纳秒
engine:db:mutex:wait:nanos	等待 db 的 mutex 的时间，单位纳秒
engine:rate:limit:delay:millis	未发现调用
engine:num:iterators	已弃用
engine:number:multiget:get	DB::MultiGet() 调用的次数
engine:number:multiget:keys:read	DB::MultiGet() 读取的 key 数量
engine:number:multiget:bytes:read	DB::MultiGet() 读取的字节数
engine:number:deletes:filtered	未发现调用
engine:number:merge:failures	失败的 Merge 操作数量
engine:bloom:filter:prefix:checked	在文件上创建迭代器之前检查 bloom 的次数
engine:bloom:filter:prefix:useful	在文件上创建迭代器之前检查 bloom 中，避免了创建迭代器的次数。
engine:number:reseeks:iteration	在一次迭代中，为了跳过大量具有相同 userkey 的 key，我们必须 reseek 的次数。
engine:getupdatessince:calls	GetUpdatesSince() 的调用次数，用于跟踪事务日志迭代器刷新。
engine:wal:synced	完成 wal 文件 sycn 的次数
engine:write:timeout	未发现调用
engine:compact:read:marked:bytes	compact 由 DB::SuggestCompactRange() 标记要 compact 的文件时读的字节数
engine:compact:read:periodic:bytes	compact 过旧的 sst 文件时读的字节数
engine:compact:read:ttl:bytes	基于 TTL 的 compaction 读的字节数
engine:compact:write:marked:bytes	compact 由 DB::SuggestCompactRange() 标记要 compact 的文件时写的字节数
engine:compact:write:periodic:bytes	compact 过旧的 sst 文件时写的字节数
engine:compact:write:ttl:bytes	基于 TTL 的 compaction 写的字节数
engine:number:direct:load:table:properties	不用创建 table reader，直接就能从文件加载获得的 table 属性数量
engine:merge:operation:time:nanos	Merge 操作的总耗时，单位 ns
engine:filter:operation:time:nanos	compaction 中 filter 操作的总耗时，单位 ns
engine:read:amp:estimate:useful:bytes	写放大实际用到的字节数
engine:read:amp:total:read:bytes	写放大全部读取的字节数
engine:number:rate_limiter:drains	速率限制器的字节被完全消耗的重新填充间隔数。
engine:number:iter:skip	DBIter::Next() 跳过的 key 的数量
engine:number:multiget:keys:found	MultiGet() 实际找到的 key 的数量
engine:num:iterator:created	已创建的 iterator 数量
engine:num:iterator:deleted	已删除的 iterator 数量
engine:files:marked:trash	被 sst 文件 manager 标记为垃圾的文件数
engine:files:deleted:immediately	被 sst 文件 manager 通过 DeleteScheduler 立即删除的文件数
engine:error:handler:bg:errro:count	bg error handler 的数量
engine:error:handler:bg:io:errro:count	bg io error handler 的数量
engine:error:handler:bg:retryable:io:errro:count	bg retryable io error handler 的数量
engine:error:handler:autoresume:count	ErrorHandler 自动恢复 bg error 的次数
engine:error:handler:autoresume:retry:total:count	ErrorHandler 自动恢复中重试的次数
engine:error:handler:autoresume:success:count	ErrorHandler 自动恢复成功的次数
engine:bytes:written	DB::Put()、DB::Delete()、DB::Merge()、DB::Write() 发出的未压缩字节数。
engine:wal:bytes	已写入 wal 的字节数
engine:flush:write:bytes	flush 期间写入的字节数
engine:write:self	通过请求线程处理完成的写操作数量。
engine:write:other	通过写入队列头部的线程处理完成的写操作数量
engine:write:wal	请求 WAL 的 Write 调用数
engine:compact:read:bytes	compaction 期间读取的字节数
engine:compact:write:bytes	compaction 期间写入的字节数
engine:lcompact:write:bytes:raw	lcompact 中原始数据的大小，包括 key 和 value
engine:dcompact:write:bytes:raw	dcompact 中原始数据的大小，包括 key 和 value
engine:remote:compact:read:bytes	remote compaction 期间读取的字节数
engine:remote:compact:write:bytes	remote compaction 期间写入的字节数
engine:superversion_acquires	获得的 superversion 数量
engine:superversion_cleanups	删除的 superversion 数量
engine:superversion_releases	释放的 superversion 数量

2.2.2. aggregate

监控项	含义
write bytes	rocksdb.bytes.written、rocksdb.wal.bytes、rocksdb.flush.write.bytes的相关速率，具体看图表 label。
write batch	rocksdb.write.self、rocksdb.write.other、rocksdb.write.wal的相关速率，具体看图表 label。
compact write	rocksdb.compact.write.bytes、rocksdb.lcompact.write.bytes.raw、rocksdb.remote.compact.write.bytes、rocksdb.dcompact.write.bytes.raw的相关速率，具体看图表 label。
compact read	rocksdb.compact.read.bytes、rocksdb.remote.compact.read.bytes的相关速率，具体看图表 label。
superversion	rocksdb.number.superversion_acquires、rocksdb.number.superversion_releases、rocksdb.number.superversion_cleanups的相关速率，具体看图表 label。

Todis 监控指标

原文：Grafana 监控指标说明 —— Todis 部分

1. length histogram

序号	指标	含义
1	key add	增加的 key 的长度
2	field add	增加的 field 的长度
3	value add	增加的 value 的长度
4	key del	删除的 key 的长度
5	field del	删除的 field 的长度
6	value del	删除的 value 的长度

2. time histogram

序号	指标	含义
7	append	append 命令的耗时
8	bitcount	bitcount 命令的耗时
9	bitop	bitop 命令的耗时
10	bitpos	bitpos 命令的耗时
11	command	command 命令的耗时
12	decr	decr 命令的耗时
13	decrby	decrby 命令的耗时
14	del	del 命令的耗时
15	delvx	delvx 命令的耗时
16	exists	exists 命令的耗时
17	expire	expire 命令的耗时
18	expireat	expireat 命令的耗时
19	get	get 命令的耗时
20	getbit	getbit 命令的耗时
21	getrange	getrange 命令的耗时
22	getset	getset 命令的耗时
23	hdel	hdel 命令的耗时
24	hexists	hexists 命令的耗时
25	hget	hget 命令的耗时
26	hgetall	hgetall 命令的耗时
27	hincrby	hincrby 命令的耗时
28	hincrbyfloat	hincrbyfloat 命令的耗时
29	hkeys	hkeys 命令的耗时
30	hlen	hlen 命令的耗时
31	hmget	hmget 命令的耗时
32	hmset	hmset 命令的耗时
33	hscan	hscan 命令的耗时
34	hscanx	hscanx 命令的耗时
35	hset	hset 命令的耗时
36	hsetnx	hsetnx 命令的耗时
37	hstrlen	hstrlen 命令的耗时
38	hvals	hvals 命令的耗时
39	incr	incr 命令的耗时
40	incrby	incrby 命令的耗时
41	incrbyfloat	incrbyfloat 命令的耗时
42	keys	keys 命令的耗时
43	lindex	lindex 命令的耗时
44	linsert	linsert 命令的耗时
45	llen	llen 命令的耗时
46	lpop	lpop 命令的耗时
47	lpush	lpush 命令的耗时
48	lpushx	lpushx 命令的耗时
49	lrange	lrange 命令的耗时
50	lrem	lrem 命令的耗时
51	lset	lset 命令的耗时
52	ltrim	ltrim 命令的耗时
53	mget	mget 命令的耗时
54	mset	mset 命令的耗时
55	msetnx	msetnx 命令的耗时
56	persist	persist 命令的耗时
57	pexpire	pexpire 命令的耗时
58	pexpireat	pexpireat 命令的耗时
59	pkhrscanrange	pkhrscanrange 命令的耗时
60	pkhscanrange	pkhscanrange 命令的耗时
61	pkrscanrange	pkrscanrange 命令的耗时
62	pkscanrange	pkscanrange 命令的耗时
63	pksetexat	pksetexat 命令的耗时
64	psetex	psetex 命令的耗时
65	pttl	pttl 命令的耗时
66	rpop	rpop 命令的耗时
67	rpoplpush	rpoplpush 命令的耗时
68	rpush	rpush 命令的耗时
69	rpushx	rpushx 命令的耗时
70	sadd	sadd 命令的耗时
71	scan	scan 命令的耗时
72	scanx	scanx 命令的耗时
73	scard	scard 命令的耗时
74	sdiff	sdiff 命令的耗时
75	sdiffstore	sdiffstore 命令的耗时
76	set	set 命令的耗时
77	setbit	setbit 命令的耗时
78	setex	setex 命令的耗时
79	setnx	setnx 命令的耗时
80	setrange	setrange 命令的耗时
81	sinter	sinter 命令的耗时
82	sinterstore	sinterstore 命令的耗时
83	sismember	sismember 命令的耗时
84	smembers	smembers 命令的耗时
85	smove	smove 命令的耗时
86	spop	spop 命令的耗时
87	srandmember	srandmember 命令的耗时
88	srem	srem 命令的耗时
89	sscan	sscan 命令的耗时
90	strlen	strlen 命令的耗时
91	sunion	sunion 命令的耗时
92	sunionstore	sunionstore 命令的耗时
93	ttl	ttl 命令的耗时
94	type	type 命令的耗时
95	zadd	zadd 命令的耗时
96	zcard	zcard 命令的耗时
97	zcount	zcount 命令的耗时
98	zincrby	zincrby 命令的耗时
99	zinterstore	zinterstore 命令的耗时
100	zlexcount	zlexcount 命令的耗时
101	zrangebyscore	zrangebyscore 命令的耗时
102	zrank	zrank 命令的耗时
103	zrem	zrem 命令的耗时
104	zremrangebylex	zremrangebylex 命令的耗时
105	zremrangebyrank	zremrangebyrank 命令的耗时
106	zremrangebyscore	zremrangebyscore 命令的耗时
107	zrevrange	zrevrange 命令的耗时
108	zrevrangebylex	zrevrangebylex 命令的耗时
109	zrevrangebyscore	zrevrangebyscore 命令的耗时
110	zrevrank	zrevrank 命令的耗时
111	zscan	zscan 命令的耗时
112	zscore	zscore 命令的耗时
113	zunionstore	zunionstore 命令的耗时

[dongdaoguang]

上面的指标挺多的，不过我感觉还是要做减法，就像报警一样，多了等于没有。最主要的还是是黄金三指标吧，QPS、时延、请求成功率。我经常看的一些指标如下：
pika层
1.每种命令的QPS、时延（tp9999、tp100）
2.内存/磁盘使用量
3.连接数
4.线程池队列中等待执行命令数量
5.慢命令（不包括排队时间）

rocksdb层
1.sst文件数量和数据大小
2.blob文件数量和数据大小
3.write stall次数
4.write stop次数
以上仅供参考

[chenbt-hz]

我们这边使用TiDB的一点体验，如有以下rocksdb指标监控，在异常定位处理时比较方便：
rocksdb-kv:
1.Compaction reason

2.Write Stall Reason

[rockeet]

1. ToplingDB 的指标通过 json/yaml 配置就可以了，不需要修改 pika 自身的代码。
2. Todis 的指标采集代码，pika 这边也可以直接复用

[ghost]

除了metrics，pika是不是可以提供接口，通过客户端获取rocksdb的指标，比如像properties，方便使用人员分析rocksdb