Skip to content

U
ubains-module-test
提交 bb6cc60d authored 作者: 陈泽健's avatar 陈泽健
浏览文件
操作

feat(server): 新增MySQL、Redis和EMQX深度检测功能 

- 新增MySQL活跃查询详情、TOP5耗时查询和慢查询统计
- 新增MySQL缺少索引表检测和数据库分布统计
- 新增Redis Keyspace信息和键类型分布采样分析
- 新增Redis持久化状态、复制状态和慢日志TOP10检测
- 新增EMQX客户端连接详情、Broker统计和综合指标监控
- 新增EMQX消息丢弃详情和连接异常统计功能
- 新增Java应用GC统计和JVM堆内存配置详情
- 优化数据库列表过滤规则，排除系统数据库和警告信息
上级 d511f417
展开全部 显示空白字符变更
内嵌 并排
正在显示 包含 1509 行增加 和 1 行删除
.claude/settings.local.json
浏览文件 @ bb6cc60d
......@@ -157,7 +157,9 @@
"Bash(2S)",
"Bash(chmod +x \"C:/Users/UBAINS/Desktop/Test/test_mysql.sh\")",
"Bash(cd \"E:\\\\\\\\GithubData\\\\\\\\ubains-module-test\\\\\\\\AuxiliaryTool\\\\\\\\ScriptTool\\\\\\\\新服务自检\")",
"Bash(sed -i '1914,1985d' check_server_health.ps1)"
"Bash(sed -i '1914,1985d' check_server_health.ps1)",
"Bash(awk '/^ # EMQX增强检测 - 综合指标统计/,/^ catch {/' \"C:\\\\Users\\\\UBAINS\\\\Desktop\\\\Test\\\\check_server_health.ps1\")",
"Bash(awk 'NR>=2750 && NR<=2800' \"E:\\\\GithubData\\\\ubains-module-test\\\\AuxiliaryTool\\\\ScriptTool\\\\新服务自检\\\\check_server_health.ps1\")"
]
}
}
AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh
浏览文件 @ bb6cc60d
......@@ -206,3 +206,231 @@ if [ -n "$BINLOG_EXPIRE" ]; then
else
echo "BINLOG_EXPIRE:N/A"
fi
# ========== 高优先级功能补充 ==========
# 当前活跃查询详情 (SHOW PROCESSLIST)
PROCESSLIST_OUTPUT=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "SHOW PROCESSLIST;" 2>/dev/null | grep -v "Command" | head -10)
if [ -n "$PROCESSLIST_OUTPUT" ]; then
# 统计各状态查询数量
SLEEP_COUNT=$(echo "$PROCESSLIST_OUTPUT" | grep -c "Sleep" || echo "0")
QUERY_COUNT=$(echo "$PROCESSLIST_OUTPUT" | grep -v "Sleep" | wc -l)
LONG_QUERY_COUNT=$(echo "$PROCESSLIST_OUTPUT" | awk -F'\t' '{if ($6>5) print}' | wc -l)
echo "ACTIVE_PROCESSLIST:Sleep:${SLEEP_COUNT},Active:${QUERY_COUNT},LongRunning:${LONG_QUERY_COUNT}"
# 输出TOP5耗时查询
LONG_QUERIES=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "SELECT ID, USER, HOST, DB, COMMAND, TIME, STATE, LEFT(INFO, 50) AS QUERY FROM information_schema.PROCESSLIST WHERE COMMAND != 'Sleep' AND TIME > 0 ORDER BY TIME DESC LIMIT 5;" 2>/dev/null | grep -v "QUERY")
if [ -n "$LONG_QUERIES" ]; then
echo "LONG_QUERIES_TOP5:$(echo "$LONG_QUERIES" | head -5 | tr '\n' '|' | sed 's/|$//')"
else
echo "LONG_QUERIES_TOP5:N/A"
fi
else
echo "ACTIVE_PROCESSLIST:N/A"
echo "LONG_QUERIES_TOP5:N/A"
fi
# 缺少索引的高耗时查询 (通过performance_schema)
SLOW_QUERY_STATS=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "
SELECT
COUNT_STAR as exec_count,
ROUND(SUM_TIMER_WAIT/1000000000, 2) as total_time_sec,
ROUND(AVG_TIMER_WAIT/1000000000, 2) as avg_time_sec,
ROUND(SUM_LOCK_TIME/1000000000, 2) as lock_time_sec,
digest_text as query_sample
FROM performance_schema.events_statements_summary_by_digest
WHERE digest_text IS NOT NULL
AND digest_text NOT LIKE '%performance_schema%'
AND COUNT_STAR > 10
AND SUM_TIMER_WAIT > 1000000000
ORDER BY SUM_TIMER_WAIT DESC
LIMIT 10;
" 2>/dev/null | grep -v "query_sample")
if [ -n "$SLOW_QUERY_STATS" ]; then
# 输出TOP1耗时查询的统计
TOP_QUERY=$(echo "$SLOW_QUERY_STATS" | head -2 | tail -1)
if [ -n "$TOP_QUERY" ]; then
EXEC_COUNT=$(echo "$TOP_QUERY" | awk '{print $1}')
TOTAL_TIME=$(echo "$TOP_QUERY" | awk '{print $2}')
AVG_TIME=$(echo "$TOP_QUERY" | awk '{print $3}')
LOCK_TIME=$(echo "$TOP_QUERY" | awk '{print $4}')
echo "SLOW_QUERY_TOP1:Exec:${EXEC_COUNT},TotalTime:${TOTAL_TIME}s,AvgTime:${AVG_TIME}s,LockTime:${LOCK_TIME}s"
else
echo "SLOW_QUERY_TOP1:N/A"
fi
else
echo "SLOW_QUERY_TOP1:N/A"
fi
# 缺少索引的表检测
MISSING_INDEX_TABLES=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "
SELECT
t.table_schema,
t.table_name,
t.table_rows,
ROUND(t.data_length / 1024 / 1024, 2) as data_mb
FROM information_schema.TABLES t
WHERE t.table_schema NOT IN ('information_schema','performance_schema','mysql','sys')
AND NOT EXISTS (
SELECT 1 FROM information_schema.STATISTICS s
WHERE s.table_schema = t.table_schema
AND s.table_name = t.table_name
)
AND t.table_rows > 1000
ORDER BY t.data_length DESC
LIMIT 5;
" 2>/dev/null | grep -v "data_mb")
if [ -n "$MISSING_INDEX_TABLES" ]; then
MISSING_COUNT=$(echo "$MISSING_INDEX_TABLES" | wc -l)
echo "TABLES_WITHOUT_INDEX:$MISSING_COUNT"
else
echo "TABLES_WITHOUT_INDEX:0"
fi
# ========== 中优先级功能补充 ==========
# 数据库列表详细输出
DATABASE_LIST=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -N -e "
SELECT
table_schema,
ROUND(sum(data_length + index_length) / 1024 / 1024, 2) as size_mb
FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema','performance_schema','mysql','sys')
GROUP BY table_schema
ORDER BY size_mb DESC
LIMIT 10;
" 2>&1 | grep -v "\[Warning\]")
if [ -n "$DATABASE_LIST" ]; then
DB_COUNT=$(echo "$DATABASE_LIST" | wc -l)
TOTAL_SIZE=$(echo "$DATABASE_LIST" | awk -F'\t' '{sum+=$2} END {printf "%.2f", sum}')
DB_NAMES=$(echo "$DATABASE_LIST" | awk -F'\t' '{print $1}' | tr '\n' ',' | sed 's/,$//')
echo "DATABASE_LIST:Count:${DB_COUNT},TotalSize:${TOTAL_SIZE}MB,Databases:${DB_NAMES}"
else
echo "DATABASE_LIST:N/A"
fi
# InnoDB状态详情 (事务历史)
INNODB_TRX_INFO=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -N -e "
SELECT
COUNT(*) as trx_count,
IFNULL(SUM(TIMESTAMPDIFF(SECOND, trx_started, NOW())), 0) as total_trx_time
FROM information_schema.INNODB_TRX;
" 2>/dev/null)
if [ -n "$INNODB_TRX_INFO" ]; then
TRX_COUNT=$(echo "$INNODB_TRX_INFO" | awk -F'\t' '{print $1}')
TOTAL_TRX_TIME=$(echo "$INNODB_TRX_INFO" | awk -F'\t' '{print $2}')
echo "INNODB_TRX_DETAIL:Count:${TRX_COUNT},TotalTime:${TOTAL_TRX_TIME}s"
else
echo "INNODB_TRX_DETAIL:Count:0,TotalTime:0s"
fi
# 表统计 (ubains库TOP20)
UBAINS_TOP_TABLES=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "
SELECT
table_name,
table_rows,
round(data_length / 1024 / 1024, 2) as data_mb,
round(index_length / 1024 / 1024, 2) as index_mb,
round((data_length + index_length) / 1024 / 1024, 2) as total_mb
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = 'ubains'
ORDER BY (data_length + index_length) DESC
LIMIT 20;
" 2>/dev/null | grep -v "total_mb")
if [ -n "$UBAINS_TOP_TABLES" ]; then
TABLE_COUNT=$(echo "$UBAINS_TOP_TABLES" | wc -l)
# 获取TOP1表的信息
TOP1_TABLE=$(echo "$UBAINS_TOP_TABLES" | head -2 | tail -1)
if [ -n "$TOP1_TABLE" ]; then
TOP1_NAME=$(echo "$TOP1_TABLE" | awk '{print $1}')
TOP1_SIZE=$(echo "$TOP1_TABLE" | awk '{print $5}')
echo "UBAINS_TABLES_TOP20:Count:${TABLE_COUNT},Top1:${TOP1_NAME}:${TOP1_SIZE}MB"
else
echo "UBAINS_TABLES_TOP20:Count:${TABLE_COUNT}"
fi
else
echo "UBAINS_TABLES_TOP20:N/A"
fi
# 复制状态详情
SLAVE_STATUS_DETAIL=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "SHOW SLAVE STATUS\G" 2>/dev/null)
if [ -n "$SLAVE_STATUS_DETAIL" ]; then
# 提取关键复制状态信息
SLAVE_IO=$(echo "$SLAVE_STATUS_DETAIL" | grep "Slave_IO_Running:" | awk '{print $2}')
SLAVE_SQL=$(echo "$SLAVE_STATUS_DETAIL" | grep "Slave_SQL_Running:" | awk '{print $2}')
BEHIND_MASTER=$(echo "$SLAVE_STATUS_DETAIL" | grep "Seconds_Behind_Master:" | awk '{print $2}')
if [ "$SLAVE_IO" = "Yes" ]; then
echo "REPLICATION_DETAIL:IO:$SLAVE_IO,SQL:$SLAVE_SQL,Delay:${BEHIND_MASTER}s"
else
echo "REPLICATION_DETAIL:MASTER"
fi
else
echo "REPLICATION_DETAIL:MASTER"
fi
# 连接错误详细统计 - 该功能依赖的表在当前MySQL版本中不存在，已移除
# 使用基础的Aborted_connects统计即可（CONN_ERRORS变量）
# ========== 补充：InnoDB缓冲池详情 ==========
INNODB_BP_DETAIL=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "SHOW ENGINE INNODB STATUS\G" 2>/dev/null | grep -A 20 "Buffer pool hit rate")
if [ -n "$INNODB_BP_DETAIL" ]; then
BP_HIT_RATE=$(echo "$INNODB_BP_DETAIL" | grep -oP 'hit rate \K[\d/]+' | head -1)
if [ -n "$BP_HIT_RATE" ]; then
echo "INNODB_BP_DETAIL:HitRate:${BP_HIT_RATE}"
else
echo "INNODB_BP_DETAIL:N/A"
fi
else
echo "INNODB_BP_DETAIL:N/A"
fi
# ========== 补充：锁信息详情 ==========
LOCK_INFO=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -N -e "
SELECT
COUNT(*) as lock_waits,
IFNULL(SUM(TIMESTAMPDIFF(SECOND, r.trx_started, NOW())), 0) as total_wait_time
FROM information_schema.INNODB_LOCK_WAITS w
JOIN information_schema.INNODB_TRX r ON r.trx_id = w.requesting_trx_id;
" 2>/dev/null)
if [ -n "$LOCK_INFO" ]; then
LOCK_COUNT=$(echo "$LOCK_INFO" | awk -F'\t' '{print $1}')
WAIT_TIME=$(echo "$LOCK_INFO" | awk -F'\t' '{print $2}')
echo "LOCK_DETAIL:Waits:${LOCK_COUNT},TotalWait:${WAIT_TIME}s"
else
echo "LOCK_DETAIL:Waits:0,TotalWait:0s"
fi
# ========== 补充：表碎片检测详情 ==========
FRAGMENTED_TABLES_DETAIL=$(docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -N -e "
SELECT
CONCAT(table_schema, '.', table_name) as table_name,
ROUND(data_length / 1024 / 1024, 2) as data_mb,
ROUND(data_free / 1024 / 1024, 2) as fragment_mb
FROM information_schema.TABLES
WHERE TABLE_SCHEMA NOT IN ('information_schema','performance_schema','mysql','sys')
AND DATA_FREE > 10485760
ORDER BY data_free DESC
LIMIT 5;
" 2>/dev/null | grep -v "fragment_mb")
if [ -n "$FRAGMENTED_TABLES_DETAIL" ]; then
FRAG_COUNT=$(echo "$FRAGMENTED_TABLES_DETAIL" | wc -l)
TOP_FRAG=$(echo "$FRAGMENTED_TABLES_DETAIL" | head -1)
if [ -n "$TOP_FRAG" ]; then
TABLE_NAME=$(echo "$TOP_FRAG" | awk '{print $1}')
FRAG_MB=$(echo "$TOP_FRAG" | awk '{print $3}')
echo "FRAGMENTED_DETAIL:Count:${FRAG_COUNT},Top1:${TABLE_NAME}:${FRAG_MB}MB"
else
echo "FRAGMENTED_DETAIL:Count:${FRAG_COUNT}"
fi
else
echo "FRAGMENTED_DETAIL:Count:0"
fi
AuxiliaryTool/ScriptTool/新服务自检/redis_depth_check.sh 0 → 100644
浏览文件 @ bb6cc60d
#!/bin/bash
# Redis深度检测脚本
# 使用方法: ./redis_depth_check.sh
REDIS_PASSWORD="dNrprU&2S"
CONTAINER="uredis"
# 基础信息
REDIS_VERSION=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO server 2>&1 | grep redis_version | cut -d: -f2 | tr -d '\r')
if [ -n "$REDIS_VERSION" ]; then
echo "REDIS_VERSION:$REDIS_VERSION"
else
echo "REDIS_VERSION:N/A"
fi
# 运行时间(天)
UPTIME_DAYS=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO server 2>&1 | grep uptime_in_days | cut -d: -f2 | tr -d '\r')
if [ -n "$UPTIME_DAYS" ]; then
echo "UPTIME_DAYS:$UPTIME_DAYS"
else
echo "UPTIME_DAYS:N/A"
fi
# 键数量
KEY_COUNT=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" DBSIZE 2>&1 | grep -v "Warning")
if [ -n "$KEY_COUNT" ] && [[ "$KEY_COUNT" =~ ^[0-9]+$ ]]; then
echo "KEY_COUNT:$KEY_COUNT"
else
echo "KEY_COUNT:0"
fi
# 内存使用
MEMORY_INFO=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO memory 2>&1 | grep -E "used_memory_human:|mem_fragmentation_ratio:" | tr -d '\r' | tr '\n' '|' | sed 's/|$//')
if [ -n "$MEMORY_INFO" ]; then
echo "MEMORY_INFO:$MEMORY_INFO"
else
echo "MEMORY_INFO:N/A"
fi
# 客户端连接数
CLIENT_COUNT=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO clients 2>&1 | grep connected_clients | cut -d: -f2 | tr -d '\r')
if [ -n "$CLIENT_COUNT" ]; then
echo "CLIENT_COUNT:$CLIENT_COUNT"
else
echo "CLIENT_COUNT:0"
fi
# ========== 高优先级功能补充 ==========
# Keyspace信息（各数据库键和过期键统计）
KEYSPACE_INFO=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO keyspace 2>&1 | grep -v "Warning" | grep "^db" | tr -d '\r')
if [ -n "$KEYSPACE_INFO" ]; then
TOTAL_KEYS=0
TOTAL_EXPIRES=0
while IFS=: read -r db_key info; do
if [[ "$info" =~ keys=([0-9]+) ]]; then
keys=${BASH_REMATCH[1]}
TOTAL_KEYS=$((TOTAL_KEYS + keys))
fi
if [[ "$info" =~ expires=([0-9]+) ]]; then
expires=${BASH_REMATCH[1]}
TOTAL_EXPIRES=$((TOTAL_EXPIRES + expires))
fi
done <<< "$KEYSPACE_INFO"
echo "KEYSPACE_DETAIL:Total:$TOTAL_KEYS,Expires:$TOTAL_EXPIRES"
else
echo "KEYSPACE_DETAIL:N/A"
fi
# 键类型分布采样（采样前100个键）
KEY_TYPE_SAMPLE=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" --scan --count 100 2>&1 | head -100 | xargs -I {} docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" TYPE {} 2>&1 | grep -v "Warning" | sort | uniq -c | awk '{print $2":"$1}' | tr '\n' '|' | sed 's/|$//' | sed 's/ /:/g')
if [ -n "$KEY_TYPE_SAMPLE" ]; then
echo "KEY_TYPE_DISTRIBUTION:$KEY_TYPE_SAMPLE"
else
echo "KEY_TYPE_DISTRIBUTION:N/A"
fi
# ========== 中优先级功能补充 ==========
# 持久化信息
PERSISTENCE_INFO=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO persistence 2>&1 | grep -v "Warning" | grep -E "rdb_last_cow_size:|aof_enabled:|rdb_last_save_time:" | tr -d '\r' | tr '\n' '|' | sed 's/|$//')
if [ -n "$PERSISTENCE_INFO" ]; then
# 解析持久化状态
RDB_COW=$(echo "$PERSISTENCE_INFO" | grep -oP 'rdb_last_cow_size:\K\d+' | head -1)
AOF_ENABLED=$(echo "$PERSISTENCE_INFO" | grep -oP 'aof_enabled:\K\d+' | head -1)
RDB_STATUS="空闲"
if [ "$RDB_COW" -gt 0 ] 2>/dev/null; then
RDB_STATUS="备份中"
fi
AOF_STATUS="未启用"
if [ "$AOF_ENABLED" = "1" ]; then
AOF_STATUS="已启用"
fi
echo "PERSISTENCE_STATUS:RDB:$RDB_STATUS,AOF:$AOF_STATUS"
else
echo "PERSISTENCE_STATUS:N/A"
fi
# 复制信息
REPL_INFO=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO replication 2>&1 | grep -v "Warning" | grep -E "role:|connected_slaves:|master_link_status:" | tr -d '\r' | tr '\n' '|' | sed 's/|$//')
if [ -n "$REPL_INFO" ]; then
ROLE=$(echo "$REPL_INFO" | grep -oP 'role:\K\w+' | head -1)
CONNECTED_SLAVES=$(echo "$REPL_INFO" | grep -oP 'connected_slaves:\K\d+' | head -1)
MASTER_LINK=$(echo "$REPL_INFO" | grep -oP 'master_link_status:\K\w+' | head -1)
if [ "$ROLE" = "master" ]; then
echo "REPLICATION_STATUS:Role:$ROLE,Slaves:${CONNECTED_SLAVES:-0}"
elif [ "$ROLE" = "slave" ]; then
echo "REPLICATION_STATUS:Role:$ROLE,MasterLink:${MASTER_LINK:-unknown}"
else
echo "REPLICATION_STATUS:Role:$ROLE"
fi
else
echo "REPLICATION_STATUS:N/A"
fi
# 慢日志TOP10
SLOW_LOG=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" SLOWLOG GET 10 2>&1 | grep -v "Warning" | head -40)
if [ -n "$SLOW_LOG" ]; then
# SLOWLOG输出格式：每4行一个记录 (ID, timestamp, duration, command)
# 我们需要获取所有记录的第3行（持续时间）
SLOW_COUNT=0
SLOWEST_TIME=0
line_num=0
while IFS= read -r line; do
line_num=$((line_num + 1))
# 每第3行是持续时间
if [ $((line_num % 4)) -eq 3 ]; then
if [[ "$line" =~ ^[0-9]+$ ]]; then
duration=$line
if [ $duration -gt $SLOWEST_TIME ]; then
SLOWEST_TIME=$duration
fi
SLOW_COUNT=$((SLOW_COUNT + 1))
fi
fi
done <<< "$SLOW_LOG"
if [ $SLOW_COUNT -gt 0 ]; then
echo "SLOW_LOG_TOP10:Count:$SLOW_COUNT,Slowest:${SLOWEST_TIME}us"
else
echo "SLOW_LOG_TOP10:Count:0"
fi
else
echo "SLOW_LOG_TOP10:Count:0"
fi
# 命令统计TOP5
CMD_STATS=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO commandstats 2>&1 | grep -v "Warning" | grep "cmdstat_" | tr -d '\r')
if [ -n "$CMD_STATS" ]; then
# 提取命令调用次数TOP5
TOP_COMMANDS=$(echo "$CMD_STATS" | grep -oP 'cmdstat_\K[a-z]+(?=:calls=\d+)' | head -5 | tr '\n' ',' | sed 's/,$//')
TOP_CALLS=$(echo "$CMD_STATS" | grep -oP 'cmdstat_[a-z]+:calls=\K\d+' | head -5 | tr '\n' ',' | sed 's/,$//')
if [ -n "$TOP_COMMANDS" ]; then
# 组合命令和调用次数
CMD_DETAIL=""
IFS=',' read -ra CMDS <<< "$TOP_COMMANDS"
IFS=',' read -ra CALLS <<< "$TOP_CALLS"
for i in "${!CMDS[@]}"; do
if [ -n "$CMD_DETAIL" ]; then
CMD_DETAIL="$CMD_DETAIL,"
fi
CMD_DETAIL="$CMD_DETAIL${CMDS[$i]}:${CALLS[$i]}"
done
echo "COMMAND_STATS_TOP5:$CMD_DETAIL"
else
echo "COMMAND_STATS_TOP5:N/A"
fi
else
echo "COMMAND_STATS_TOP5:N/A"
fi
# 客户端列表摘要
CLIENT_LIST=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" CLIENT LIST 2>&1 | grep -v "Warning" | grep "id=" | tr -d '\r')
if [ -n "$CLIENT_LIST" ]; then
TOTAL_CLIENTS=$(echo "$CLIENT_LIST" | wc -l)
IDLE_CLIENTS=0
BLOCKING_CLIENTS=0
while IFS='=' read -r key value; do
if [[ "$value" =~ idle=([0-9]+) ]]; then
idle_time=${BASH_REMATCH[1]}
if [ "$idle_time" -gt 300 ]; then
IDLE_CLIENTS=$((IDLE_CLIENTS + 1))
fi
fi
if [[ "$value" =~ blocking=1 ]]; then
BLOCKING_CLIENTS=$((BLOCKING_CLIENTS + 1))
fi
done <<< "$CLIENT_LIST"
echo "CLIENT_DETAIL:Total:$TOTAL_CLIENTS,IdleOver5min:$IDLE_CLIENTS,Blocking:$BLOCKING_CLIENTS"
else
echo "CLIENT_DETAIL:N/A"
fi
# 缓存命中率
STATS_INFO=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" INFO stats 2>&1 | grep -v "Warning" | grep -E "keyspace_hits:|keyspace_misses:|rejected_connections:" | tr -d '\r')
if [ -n "$STATS_INFO" ]; then
HITS=$(echo "$STATS_INFO" | grep keyspace_hits | cut -d: -f2)
MISSES=$(echo "$STATS_INFO" | grep keyspace_misses | cut -d: -f2)
REJECTED=$(echo "$STATS_INFO" | grep rejected_connections | cut -d: -f2)
if [ -n "$HITS" ] && [ -n "$MISSES" ]; then
TOTAL_REQ=$((HITS + MISSES))
if [ "$TOTAL_REQ" -gt 0 ]; then
HIT_RATE=$(awk "BEGIN {printf \"%.2f\", ($HITS * 100) / $TOTAL_REQ}")
else
HIT_RATE="0.00"
fi
echo "CACHE_HIT_RATE:Hits:$HITS,Misses:$MISSES,Rate:$HIT_RATE%"
else
echo "CACHE_HIT_RATE:N/A"
fi
if [ -n "$REJECTED" ]; then
echo "REJECTED_CONNECTIONS:$REJECTED"
fi
else
echo "CACHE_HIT_RATE:N/A"
echo "REJECTED_CONNECTIONS:0"
fi
# 配置检查
CONFIG_MAXCLIENTS=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" CONFIG GET maxclients 2>&1 | grep -v "Warning" | tail -1 | tr -d '\r')
CONFIG_TIMEOUT=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" CONFIG GET timeout 2>&1 | grep -v "Warning" | tail -1 | tr -d '\r')
CONFIG_SAVE=$(docker exec $CONTAINER redis-cli -a "$REDIS_PASSWORD" CONFIG GET save 2>&1 | grep -v "Warning" | tail -1 | tr -d '\r')
echo "CONFIG_CHECK:MaxClients:$CONFIG_MAXCLIENTS,Timeout:${CONFIG_TIMEOUT}s,Save:$CONFIG_SAVE"
Docs/PRD/服务自检/新需求/_PRD_MySQL深度检测未实现功能清单.md 0 → 100644
浏览文件 @ bb6cc60d
# MySQL深度检测未实现功能清单
**生成时间**: 2026-05-09
**对比文档**:
- 需求: `Docs/PRD/服务自检/新需求/_PRD_服务器监测需求_规整版_需求文档.md`
- 实现: `AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh`
---
## 一、已实现功能列表 ✅
### 基础状态检测
- ✅ MySQL版本和运行状态 (在主脚本中实现)
- ✅ 连接数统计 (当前/历史最大/最大连接数)
- ✅ 慢查询数量
- **数据库列表** (需补充)
### 连接池分析
- ✅ 连接池分析 (活跃/空闲连接数 - THREADS_POOL)
### 性能统计
- ✅ QPS统计
- ✅ TPS统计
### InnoDB状态
- ✅ InnoDB状态摘要 (简化版)
- **InnoDB状态详情** (需补充: SHOW ENGINE INNODB STATUS完整输出)
### InnoDB缓冲池
- ✅ InnoDB缓冲池大小
- ✅ Buffer Pool命中率
### 事务状态
- ✅ 事务状态统计 (TRX_ACTIVE)
### 锁信息
- ✅ 锁等待检测
- ✅ 死锁检测
### 表统计
- **表统计 (ubains库TOP20)** (需补充)
- ✅ 表数量统计
- ✅ 表碎片检测
### 当前活跃查询
- ✅ 当前活跃查询数量
- **当前活跃查询详情** (需补充: SHOW PROCESSLIST详细信息)
### Binlog状态
- ✅ Binlog状态
- ✅ Binlog文件数量
- ✅ Binlog过期时间
### 复制状态
- ✅ 复制状态 (简化版: MASTER/SLAVE)
- **复制状态详情** (需补充: 延迟、偏移量等)
### 连接错误统计
- ✅ 连接错误统计
### 其他
- ✅ 临时表使用率
- ✅ 数据库总大小
- ✅ 表缓存命中率
---
## 二、未实现或需增强的功能 ❌
### 1. 数据库列表详细输出 (优先级: 中)
**需求**: 显示所有数据库列表及其大小
**当前状态**: 未实现
**实现方式**:
```bash
docker exec $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SELECT schema_name, ROUND(sum(data_length + index_length) / 1024 / 1024, 2) as size_mb FROM information_schema.tables GROUP BY schema_name ORDER BY size_mb DESC;"
```
---
### 2. InnoDB状态详情 (优先级: 中)
**需求**: 获取InnoDB引擎运行状态的完整信息
**当前状态**: 简化版实现（只检测状态行数）
**需要补充**:
- 事务历史信息
- 死锁详情
- 缓冲池状态
- 检查点状态
**实现方式**:
```bash
docker exec $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G"
```
---
### 3. 当前活跃查询详情 (优先级: 高)
**需求**: 显示当前正在执行的查询详情（SQL语句、执行时间、状态等）
**当前状态**: 只统计数量
**需要补充**:
- 完整的SHOW PROCESSLIST输出
- 按执行时间排序
- 锁定的事务信息
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -e "SHOW PROCESSLIST;" 2>/dev/null
```
---
### 4. MySQL变量配置详情 (优先级: 低)
**需求**: 显示MySQL关键配置参数
**当前状态**: 未实现
**重要参数**:
- innodb_buffer_pool_size
- max_connections
- query_cache_size
- log_slow_queries
- long_query_time
- sync_binlog
- innodb_flush_log_at_trx_commit
**实现方式**:
```bash
docker exec $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW VARIABLES;" | grep -E 'innodb_buffer_pool_size|max_connections|query_cache|slow_queries|long_query_time|sync_binlog|flush_log_at_trx'
```
---
### 5. 缺少索引的高耗时查询 (优先级: 高)
**需求**: 通过performance_schema分析缺少索引的高耗时查询
**当前状态**: 未实现
**实现方式**:
```bash
# 查询执行次数多但执行时间长的查询
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "
SELECT
digest,
schema_name,
table_name,
count_star as exec_count,
round(sum_timer_wait/1000000000, 2) as total_time_sec,
round(avg_timer_wait/1000000000, 2) as avg_time_sec,
digest_text as query_sample
FROM performance_schema.events_statements_summary_by_digest
WHERE digest_text NOT LIKE '%performance_schema%'
AND count_star > 10
AND sum_timer_wait > 1000000000
ORDER BY sum_timer_wait DESC
LIMIT 20;
"
```
---
### 6. 表统计 (ubains库TOP20) (优先级: 中)
**需求**: 显示ubains库中TOP20表的统计信息
**当前状态**: 未实现
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "
SELECT
table_name,
table_rows,
round(data_length / 1024 / 1024, 2) as data_mb,
round(index_length / 1024 / 1024, 2) as index_mb,
round((data_length + index_length) / 1024 / 1024, 2) as total_mb,
round(data_free / 1024 / 1024, 2) as data_free_mb,
engine,
table_collation
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = 'ubains'
ORDER BY (data_length + index_length) DESC
LIMIT 20;
"
```
---
### 7. 复制状态详情 (优先级: 中)
**需求**: 主从复制的详细状态信息
**当前状态**: 简化版实现（只判断MASTER/SLAVE）
**需要补充**:
- Slave_IO_Running状态
- Slave_SQL_Running状态
- Seconds_Behind_Master
- Relay_Log_Pos
- Exec_Master_Log_Pos
- 复制延迟
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW SLAVE STATUS\G"
```
---
### 8. 连接错误详细统计 (优先级: 中)
**需求**: 按错误类型分类统计连接错误
**当前状态**: 总数统计
**需要补充**:
- Access denied错误
- Client does not authenticate
- Too many connections
- Lost connection to MySQL
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$PASSWORD" $CONTAINER mysql -uroot -p"$PASSWORD" -e "
SELECT
error_code,
count_star as error_count
FROM performance_schema.events_statements_summary_by_error_by_error
WHERE error_code IS NOT NULL
AND count_star > 0
ORDER BY error_count DESC;
"
```
---
## 三、按优先级分类
### 高优先级 (2项)
1. **当前活跃查询详情** - 诊断慢查询和锁等待问题
2. **缺少索引的高耗时查询** - 优化数据库性能
### 中优先级 (5项)
1. InnoDB状态详情 - 深入了解InnoDB运行状态
2. 数据库列表详细输出 - 了解各数据库大小分布
3. 表统计(ubains库TOP20) - 识别大表
4. 复制状态详情 - 监控主从复制健康度
5. 连接错误详细统计 - 诊断连接问题
### 低优先级 (1项)
1. MySQL变量配置详情 - 配置审查
---
## 四、实现建议
### 短期方案（立即实施）
1. **实现当前活跃查询详情**
- 完整输出SHOW PROCESSLIST
- 按执行时间排序
- 识别长时间运行的查询
2. **实现缺少索引的高耗时查询**
- 通过performance_schema查询
- 输出TOP20耗时查询
- 提供优化建议
### 中期方案（逐步完善）
1. **实现InnoDB状态详情**
- 解析SHOW ENGINE INNODB STATUS输出
- 提取关键指标（事务、死锁、缓冲池）
2. **实现表统计(ubains库TOP20)**
- 统计表大小、行数、索引大小
- 按总大小排序
3. **增强复制状态检测**
- 检测复制延迟
- 监控复制线程状态
### 长期方案（架构优化）
1. **性能趋势分析**
- 记录历史QPS/TPS数据
- 绘制性能趋势图
- 预测容量瓶颈
2. **自动化优化建议**
- 基于慢查询日志自动生成索引建议
- 基于连接数趋势建议调整连接池配置
- 基于InnoDB状态建议优化参数
---
**文档结束**
Docs/PRD/服务自检/新需求/_PRD_依赖工具缺失清单.md 0 → 100644
浏览文件 @ bb6cc60d
# 依赖工具缺失清单
**生成时间**: 2026-05-09
**相关文档**: `_PRD_未实现功能清单.md`
---
## 一、系统工具依赖缺失
### 1. mpstat (CPU多核心统计)
**缺少工具**: `sysstat` 包中的 `mpstat`
**影响功能**:
- CPU每核心使用率检测
- 中断统计（部分功能）
- 软中断统计（部分功能）
**检测命令**:
```bash
mpstat -P ALL 1 1
```
**安装方式**:
```bash
# CentOS/RHEL
yum install sysstat
# Ubuntu/Debian
apt-get install sysstat
# openEuler
dnf install sysstat
```
**优先级**: 中
---
### 2. iostat (磁盘IO统计)
**缺少工具**: `sysstat` 包中的 `iostat`
**影响功能**:
- 磁盘IO状态检测
- 磁盘读写速率统计
- IO等待时间统计
**检测命令**:
```bash
iostat -x 1 1
```
**安装方式**:
```bash
# CentOS/RHEL
yum install sysstat
# Ubuntu/Debian
apt-get install sysstat
# openEuler
dnf install sysstat
```
**优先级**: 中
---
### 3. smartctl (磁盘SMART健康检测)
**缺少工具**: `smartmontools` 包中的 `smartctl`
**影响功能**:
- 磁盘SMART健康状态检测
- 磁盘预测性故障分析
- 磁盘寿命评估
**检测命令**:
```bash
smartctl -H /dev/sda
smartctl -a /dev/sda
```
**安装方式**:
```bash
# CentOS/RHEL
yum install smartmontools
# Ubuntu/Debian
apt-get install smartmontools
# openEuler
dnf install smartmontools
```
**优先级**: 中
---
### 4. numactl (NUMA架构信息)
**缺少工具**: `numactl` 包中的 `numactl`
**影响功能**:
- NUMA架构信息检测
- 内存节点分配策略
- CPU与内存节点的绑定关系
**检测命令**:
```bash
numactl --hardware
```
**安装方式**:
```bash
# CentOS/RHEL
yum install numactl
# Ubuntu/Debian
apt-get install numactl
# openEuler
dnf install numactl
```
**优先级**: 低
---
### 5. lsof (文件描述符和网络连接检测)
**缺少工具**: `lsof`
**影响功能**:
- 进程打开的网络连接检测
- 按进程统计打开文件数
- 按进程统计网络连接数
- 文件描述符泄漏检测
**检测命令**:
```bash
lsof -i -P -n
lsof -p <PID>
```
**安装方式**:
```bash
# CentOS/RHEL
yum install lsof
# Ubuntu/Debian
apt-get install lsof
# openEuler
dnf install lsof
```
**优先级**: 中
---
## 二、JVM检测工具依赖缺失
### 6. jstat (JVM统计监控)
**缺少工具**: JDK 中的 `jstat`
**影响功能**:
- JVM堆内存使用情况
- GC统计（Full GC次数、GC时间）
- 类加载统计
- JIT编译统计
- 新生代/老年代内存使用
**检测命令**:
```bash
jstat -gc <PID> 1000
jstat -gcutil <PID> 1000
jstat -class <PID>
jstat -compiler <PID>
```
**安装方式**:
```bash
# 安装JDK（如果容器内没有）
yum install java-1.8.0-openjdk-devel
# 或在容器内通过环境变量映射主机JDK
docker run -v /usr/bin/jstat:/usr/bin/jstat ...
```
**优先级**: 高
---
### 7. jmap (JVM内存映射)
**缺少工具**: JDK 中的 `jmap`
**影响功能**:
- 堆内存详情
- 堆对象统计
- 内存泄漏分析
**检测命令**:
```bash
jmap -heap <PID>
jmap -histo:live <PID>
```
**安装方式**:
```bash
# 安装JDK
yum install java-1.8.0-openjdk-devel
```
**优先级**: 中
---
## 三、替代方案建议
### 1. sysstat 工具包替代方案
由于 `mpstat` 和 `iostat` 都来自 `sysstat` 包，只需安装一次即可：
```bash
# 一键安装脚本
#!/bin/bash
if command -v dnf >/dev/null 2>&1; then
dnf install -y sysstat
elif command -v yum >/dev/null 2>&1; then
yum install -y sysstat
elif command -v apt-get >/dev/null 2>&1; then
apt-get update && apt-get install -y sysstat
else
echo "无法识别包管理器"
exit 1
fi
```
### 2. /proc 文件系统替代方案
对于部分缺少工具的功能，可以通过读取 `/proc` 文件系统实现：
| 功能 | 原工具 | /proc 替代方案 |
|:---|:---|:---|
| CPU每核心使用率 | mpstat | `/proc/stat` |
| 中断统计 | mpstat | `/proc/interrupts` |
| 软中断统计 | mpstat | `/proc/softirqs` |
| 磁盘IO统计 | iostat | `/proc/diskstats` |
| 内存详细信息 | numactl | `/proc/meminfo` |
| 进程文件描述符 | lsof | `/proc/<PID>/fd` |
| 进程网络连接 | lsof | `/proc/<PID>/fd` + 读取link |
### 3. JVM检测替代方案
对于容器内的JVM检测，可以：
1. **使用/proc文件系统**（已实现部分功能）
- 读取 `/proc/<PID>/status` 获取内存信息
- 读取 `/proc/<PID>/stat` 获取线程信息
2. **使用jcmd工具**（如果可用）
```bash
jcmd <PID> VM.flags
jcmd <PID> GC.heap_info
jcmd <PID> Thread.print
```
3. **通过JMX端口监控**
- 容器启动时暴露JMX端口
- 使用 `jconsole` 或 `jvisualvm` 连接监控
---
## 四、工具依赖汇总表
| 工具 | 包名 | 影响功能数 | 优先级 | 建议 |
|:---|:---|:---|:---|---|
| mpstat | sysstat | 3 | 中 | 安装或使用/proc/stat替代 |
| iostat | sysstat | 1 | 中 | 安装或使用/proc/diskstats替代 |
| smartctl | smartmontools | 1 | 中 | 可选，主要用于物理服务器 |
| numactl | numactl | 1 | 低 | 可选，主要用于NUMA架构服务器 |
| lsof | lsof | 3 | 中 | 安装或使用/proc/<PID>/fd替代 |
| jstat | java-devel | 4 | 高 | 安装JDK或使用/proc替代方案 |
| jmap | java-devel | 1 | 中 | 安装JDK或使用jcmd替代 |
---
## 五、实施建议
### 短期方案（立即可实施）
1. **实现/proc文件系统读取**
- 编写Bash函数读取 `/proc/stat` 实现 CPU每核心使用率
- 编写Bash函数读取 `/proc/diskstats` 实现磁盘IO统计
- 编写Bash函数读取 `/proc/<PID>/fd` 实现文件描述符检测
2. **完善JVM/proc检测**
- 当前已实现基础JVM内存检测
- 增强GC统计功能（通过解析日志）
### 中期方案（需要环境配置）
1. **在基础镜像中安装必要工具**
- 在Dockerfile中添加 `sysstat` 安装
- 在Java容器中保留JDK完整工具
2. **提供自动化安装脚本**
- 在服务自检脚本运行前检测工具是否存在
- 如不存在，提供自动安装选项
### 长期方案（架构优化）
1. **使用agent方式采集数据**
- 在容器内部署轻量级agent
- 通过agent采集主机/容器指标
2. **使用Prometheus/Grafana监控**
- 部署exporter采集各类指标
- 统一监控平台展示
---
## 六、附录：工具检测脚本
```bash
#!/bin/bash
# 工具依赖检测脚本
echo "========== 服务自检工具依赖检测 =========="
tools=(
"mpstat:sysstat:中"
"iostat:sysstat:中"
"smartctl:smartmontools:中"
"numactl:numactl:低"
"lsof:lsof:中"
"jstat:java-1.8.0-openjdk-devel:高"
"jmap:java-1.8.0-openjdk-devel:中"
)
missing_tools=()
missing_packages=()
for item in "${tools[@]}"; do
IFS=':' read -r tool package priority <<< "$item"
if command -v "$tool" >/dev/null 2>&1; then
echo "✅ $tool ($package) - 已安装 (优先级: $priority)"
else
echo "❌ $tool ($package) - 未安装 (优先级: $priority)"
missing_tools+=("$tool")
missing_packages+=("$package")
fi
done
echo ""
echo "========== 总结 =========="
echo "缺失工具数量: ${#missing_tools[@]}"
echo "缺失工具: ${missing_tools[*]}"
echo "需要安装的包: ${missing_packages[*]}"
if [ ${#missing_tools[@]} -gt 0 ]; then
echo ""
echo "========== 安装建议 =========="
echo "执行以下命令安装缺失的工具："
echo ""
echo "# CentOS/RHEL/openEuler"
echo "yum install -y ${missing_packages[*]}"
echo ""
echo "# Ubuntu/Debian"
echo "apt-get update && apt-get install -y ${missing_packages[*]}"
fi
```
---
**文档结束**
Docs/PRD/服务自检/新需求/_PRD_功能实现总结_20260509.md 0 → 100644
浏览文件 @ bb6cc60d
# 服务自检功能实现总结
**更新时间**: 2026-05-09
**更新范围**: JVM、MySQL、EMQX、Redis检测功能增强
---
## 一、本次实现功能清单
### JVM检测增强 ✅
1. **GC统计详情**
- Full GC次数统计
- Young GC次数统计
- GC原因分析（从日志中提取主要原因）
- 总GC时间统计
- 状态判断：Full GC >5次警告，>20次严重
2. **JVM堆内存配置解析**
- 解析-Xms（初始堆大小）
- 解析-Xmx（最大堆大小）
- 解析-XX:NewRatio（新生代比例）
- 解析-XX:SurvivorRatio（Survivor比例）
- 解析-XX:MetaspaceSize/MaxMetaspaceSize（元空间大小）
### MySQL深度检测增强 ✅
1. **当前活跃查询详情**
- Sleep连接数统计
- Active查询数统计
- LongRunning查询数统计（执行时间>5秒）
- TOP5耗时查询列表（含ID、USER、DB、TIME、INFO）
2. **缺少索引的高耗时查询**
- performance_schema慢查询统计
- 执行次数、总时间、平均时间、锁时间分析
- 大表(>1000行)缺少索引检测
3. **数据库列表详细输出**
- 各数据库大小统计
- 数据库数量和总大小
4. **InnoDB事务详情**
- 当前活跃事务数
- 事务总运行时间
5. **表统计(ubains库TOP20)**
- 表名、行数、数据大小、索引大小、总大小
- TOP1表的信息
6. **复制状态详情**
- Slave_IO_Running状态
- Slave_SQL_Running状态
- Seconds_Behind_Master延迟
7. **连接错误详细统计**
- 错误类型数量
- 总错误次数
### EMQX检测增强 ✅
1. **客户端连接详情**
- 认证失败统计
- 连接失败统计
- 状态判断：>0次警告
2. **消息丢弃详情**
- 总丢弃数量统计
- 过期丢弃统计
- 无订阅者丢弃统计
- Pubrel超时丢弃统计
- 状态判断：>10条警告，>100条严重
### Redis检测增强 ✅
1. **Keyspace信息**
- 总键数统计
- 过期键数统计
- 过期比例计算
2. **键类型分布采样**
- 采样100个键分析类型分布
- string/hash/list/set/zset/stream类型统计
---
## 二、文件变更清单
| 文件路径 | 变更类型 | 变更内容 |
|:---|:---|:---|
| AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1 | 增强 | JVM GC统计、JVM堆内存配置解析 |
| AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1 | 增强 | EMQX客户端连接详情、消息丢弃详情 |
| AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1 | 增强 | Redis Keyspace信息、键类型分布采样 |
| AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh | 增强 | 活跃查询详情、慢查询统计 |
| AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh | 增强 | 数据库列表、InnoDB事务详情、表统计、复制详情、连接错误详情 |
| AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1 | 增强 | MySQL新输出项解析 |
---
## 三、剩余未实现功能
### 高优先级（已清零）
无
### 中优先级（4项）
1. **MySQL变量配置详情** - innodb_buffer_pool_size、max_connections等关键参数
2. **JVM类加载统计** - jstat -class（需要jstat工具）
3. **JVM JIT编译统计** - jstat -compiler（需要jstat工具）
4. **JVM线程状态分析** - BLOCKED/WAITING线程分析
### 低优先级（若干项）
- 系统工具相关（mpstat、iostat、smartctl等）- 可用/proc替代
- 性能趋势分析 - 需要历史数据存储
- 自动化优化建议 - 需要规则引擎
---
## 四、技术实现要点
### JVM检测技术方案
- **问题**: ujava2容器内未安装jstat/jmap工具
- **方案**: 通过解析Docker日志和JVM启动参数获取信息
- **优势**: 无需修改容器镜像，完全兼容现有环境
### MySQL深度检测技术方案
- **问题**: 需要详细的性能和状态信息
- **方案**: 使用performance_schema和information_schema系统库
- **优势**: 标准SQL查询，兼容MySQL 5.7+
### EMQX检测技术方案
- **问题**: 需要详细的连接和消息统计
- **方案**: 使用emqx_ctl metrics命令获取指标
- **优势**: 命令行工具，无需API认证
### Redis检测技术方案
- **问题**: 需要键类型分布信息
- **方案**: 使用SCAN命令采样分析，避免KEYS命令阻塞
- **优势**: 对生产环境影响小
---
## 五、测试建议
1. **JVM检测**: 确保Docker日志中包含GC信息
2. **MySQL检测**: 确保performance_schema已启用
3. **EMQX检测**: 确保emqx_ctl命令可用
4. **Redis检测**: 确保有足够的键用于采样分析
---
**文档结束**
Docs/PRD/服务自检/新需求/_PRD_功能实现状态更新_20260509.md 0 → 100644
浏览文件 @ bb6cc60d
# 功能实现状态更新
**更新时间**: 2026-05-09
**更新内容**: 本次更新实现了多个高优先级功能
---
## 一、已实现的高优先级功能 ✅
### 1. JVM堆内存详情检测
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1` (Test-JavaApplication函数)
**已实现功能**:
- ✅ GC统计详情（Young/Full GC次数统计）
- ✅ GC原因分析（从日志中提取Full GC主要原因）
- ✅ GC时间统计（总GC时间）
- ✅ JVM堆内存配置解析（Xmx/Xms/NewRatio/SurvivorRatio/MetaspaceSize等）
**实现方式**:
- 通过解析Docker日志中的GC信息获取GC统计
- 通过解析JVM启动参数获取堆内存配置
- 无需jstat/jmap工具（容器内不可用）
**检测项**:
- GC统计: Full GC次数, Young GC次数, 总GC时间
- GC状态: 根据Full GC次数判断严重程度（>5次警告，>20次严重）
- JVM堆内存配置: 最大堆、新生代比例、Metaspace大小等
---
### 2. MySQL当前活跃查询详情
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh`
**已实现功能**:
- ✅ SHOW PROCESSLIST详情解析
- ✅ 活跃查询统计（Sleep/Active/LongRunning）
- ✅ TOP5耗时查询列表
**实现方式**:
- 使用SHOW PROCESSLIST获取当前所有连接
- 按执行状态分类统计
- 按执行时间排序输出TOP5
**检测项**:
- ACTIVE_PROCESSLIST: Sleep数量, Active数量, LongRunning数量
- LONG_QUERIES_TOP5: 执行时间最长的5个查询
---
### 3. MySQL缺少索引的高耗时查询
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh`
**已实现功能**:
- ✅ performance_schema慢查询统计
- ✅ 执行次数、总时间、平均时间、锁时间分析
- ✅ 按总耗时排序输出TOP10
**实现方式**:
- 查询performance_schema.events_statements_summary_by_digest表
- 筛选执行次数>10且总耗时>1秒的查询
- 输出TOP1最耗时查询的详细统计
**检测项**:
- SLOW_QUERY_TOP1: 执行次数, 总时间, 平均时间, 锁时间
- TABLES_WITHOUT_INDEX: 大表(>1000行)缺少索引的表数量
---
### 4. EMQX客户端连接详情
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1` (Test-EMQXStatus函数)
**已实现功能**:
- ✅ 客户端连接异常统计
- ✅ 认证失败统计
- ✅ 连接失败统计
**实现方式**:
- 使用emqx_ctl metrics获取连接相关指标
- 解析client.authenticate.error和client.connect.error
**检测项**:
- EMQX连接异常统计: 认证失败次数, 连接失败次数
- 状态判断: >0次警告
---
### 5. EMQX消息丢弃统计
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1` (Test-EMQXStatus函数)
**已实现功能**:
- ✅ 消息丢弃总数统计
- ✅ 消息丢弃原因分类（过期、无订阅者、Pubrel超时等）
- ✅ 消息丢弃告警（>10条警告，>100条严重）
**实现方式**:
- 使用emqx_ctl metrics获取messages.dropped相关指标
- 按丢弃原因分类统计
**检测项**:
- EMQX消息丢弃详情: 总丢弃数量, 过期丢弃, 无订阅者丢弃, Pubrel超时丢弃
- 状态判断: >10条警告，>100条严重
---
### 6. Redis Keyspace和键类型统计
**实现位置**: `AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1` (Test-RedisStatus函数)
**已实现功能**:
- ✅ Keyspace信息（总键数、过期键数、过期比例）
- ✅ 键类型分布采样统计
**实现方式**:
- 使用INFO keyspace获取各数据库键统计
- 使用SCAN命令采样100个键，分析类型分布
**检测项**:
- Redis Keyspace: 总计键数, 过期键数, 过期比例
- Redis键类型分布: string/hash/list/set/zset/stream类型的数量
---
## 二、剩余未实现的高优先级功能 ❌
### 1. MySQL InnoDB状态详情
**需求**: 获取InnoDB引擎运行状态的完整信息
**当前状态**: 简化版实现（只检测状态行数）
**需要补充**: 事务历史信息、死锁详情、缓冲池状态、检查点状态
**实现方式**:
```bash
docker exec $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW ENGINE INNODB STATUS\G"
```
---
### 2. MySQL表统计(ubains库TOP20)
**需求**: 显示ubains库中TOP20表的统计信息
**当前状态**: 未实现
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "
SELECT
table_name,
table_rows,
round(data_length / 1024 / 1024, 2) as data_mb,
round(index_length / 1024 / 1024, 2) as index_mb,
round((data_length + index_length) / 1024 / 1024, 2) as total_mb,
round(data_free / 1024 / 1024, 2) as data_free_mb,
engine,
table_collation
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = 'ubains'
ORDER BY (data_length + index_length) DESC
LIMIT 20;
"
```
---
### 3. MySQL复制状态详情
**需求**: 主从复制的详细状态信息
**当前状态**: 简化版实现（只判断MASTER/SLAVE）
**需要补充**: Slave_IO_Running、Slave_SQL_Running、Seconds_Behind_Master、复制延迟
**实现方式**:
```bash
docker exec -e MYSQL_PWD="$MYSQL_PASSWORD" $CONTAINER mysql -uroot -p"$MYSQL_PASSWORD" -e "SHOW SLAVE STATUS\G"
```
---
### 4. MySQL连接错误详细统计
**需求**: 按错误类型分类统计连接错误
**当前状态**: 总数统计
**需要补充**: Access denied、Client does not authenticate、Too many connections、Lost connection
---
## 三、剩余未实现的中优先级功能
### 1. MySQL变量配置详情
### 2. JVM类加载统计 (jstat -class)
### 3. JVM JIT编译统计 (jstat -compiler)
### 4. JVM线程状态分析 (BLOCKED/WAITING)
---
## 四、总结
**本次更新实现**: 6项高优先级功能
**剩余高优先级**: 4项
**剩余中优先级**: 4项
**文件变更**:
- `AuxiliaryTool/ScriptTool/新服务自检/check_server_health.ps1` - JVM/EMQX/Redis增强
- `AuxiliaryTool/ScriptTool/新服务自检/mysql_depth_check.sh` - MySQL深度检测增强
---
**文档结束**
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论