✅ 好的！`procrank` 是 Android 系统中用于查看进程内存占用（PSS、RSS、VSS 等）的实用工具，其输出为**固定列宽的文本格式**（非 CSV/JSON），解析需按字符位置切片。下面我将为你提供一个**健壮、可扩展、带趋势分析的 Python 脚本**，支持： - ✅ 自动识别 `procrank` 多次采样日志（支持时间戳或序号分隔） - ✅ 按 PID 或进程名（如 `com.example.app`）提取内存序列（PSS 为主，也支持 RSS/VSS） - ✅ 计算关键趋势指标：最大值、最小值、平均值、增长斜率、波动标准差 - ✅ 生成趋势图（Matplotlib）+ 导出 CSV 数据 - ✅ 容错处理：跳过空行、标题行、异常行，支持 `procrank -t`（带时间戳）和无时间戳格式 --- ### ✅ 一、【`procrank` 日志格式说明（关键！）】 典型输出（Android 12+，`procrank` 默认列宽）： ``` PID VSS RSS PSS USS cmdline 1234 123456K 78901K 45678K 34567K com.example.app 5678 98765K 54321K 23456K 12345K system_server ... ``` > ⚠️ 注意： > - 列是**固定宽度对齐**（空格分隔但不严格，不能用 `split()` 直接切）； > - 第一行是表头（含 `PID`, `VSS`, `RSS`, `PSS`, `USS`, `cmdline`）； > - 后续每行以 `PID` 开头（纯数字），`cmdline` 在最右（可能含空格）； > - 内存单位统一为 `K`（KB），部分版本可能为 `M`（MB），脚本会自动识别。 --- ### ✅ 二、【完整 Python 解析脚本】（保存为 `parse_procrank.py`） ```python #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ procrank 日志趋势分析器 支持多采样日志（按空行或时间戳分割），提取指定进程的 PSS/RSS/VSS 序列，并计算趋势指标。 作者：AI Assistant | 适配 Android procrank 输出（v1.0） """ import re import sys import csv import argparse from datetime import datetime from typing import List, Dict, Optional, Tuple, Any import matplotlib.pyplot as plt # ==================== 配置区（可按需修改） ==================== DEFAULT_MEMORY_COL = "PSS" # 主要分析列：'PSS', 'RSS', 'VSS', 'USS' TIMEOUT_SECONDS = 300 # 进程超时阈值（秒），用于检测“长时间高内存” # =============================================================== def parse_procrank_line(line: str) -> Optional[Dict[str, Any]]: """ 解析单行 procrank 输出，返回字典，失败返回 None 支持格式：' 1234 123456K 78901K 45678K 34567K com.example.app' """ line = line.rstrip() if not line or line.startswith(" PID") or line.startswith(" PID"): return None # 跳过表头 # 正则匹配：开头 PID（至少1位数字），然后是4组内存值（数字+K/M），最后是 cmdline（非空） # 允许内存值后有空格，cmdline 可含空格（取剩余全部） match = re.match( r'^\s*(\d+)\s+([\d.]+[KM])\s+([\d.]+[KM])\s+([\d.]+[KM])\s+([\d.]+[KM])\s+(.+)$', line ) if not match: # 尝试更宽松匹配（兼容不同对齐、缺失 USS 等） parts = line.split() if len(parts) < 6: return None try: pid = parts[0] if not pid.isdigit(): return None # 取最后 1~2 个字段为 cmdline（因 cmdline 可能含空格） # 内存字段固定在前 5 位：PID, VSS, RSS, PSS, USS → cmdline 是剩余所有 vss, rss, pss, uss = parts[1:5] cmdline = " ".join(parts[5:]) match = (pid, vss, rss, pss, uss, cmdline) except (IndexError, ValueError): return None else: pid, vss, rss, pss, uss, cmdline = match.groups() def parse_mem_value(s: str) -> float: """将 '12345K' 或 '12.3M' 转为 KB 数值""" s = s.strip().upper() if s.endswith('M'): return float(s[:-1]) * 1024 elif s.endswith('K'): return float(s[:-1]) else: return float(s) # 假设是 KB try: return { "pid": int(pid), "VSS": parse_mem_value(vss), "RSS": parse_mem_value(rss), "PSS": parse_mem_value(pss), "USS": parse_mem_value(uss), "cmdline": cmdline.strip(), } except (ValueError, TypeError): return None def split_log_into_samples(log_lines: List[str]) -> List[List[str]]: """ 将日志按采样分组：支持两种模式 - 模式1：空行分隔（默认） - 模式2：以 'procrank' 或 'time=' 开头的行分隔（如 procrank -t 输出） 返回：[[sample1_line1, ...], [sample2_line1, ...], ...] """ samples = [] current_sample = [] for line in log_lines: line = line.strip() # 分隔符判断（优先级：时间戳 > 空行 > procrank 行） if (re.match(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', line) or # ISO 时间戳 re.match(r'^time=\d+', line) or line.lower().startswith('procrank')): if current_sample: samples.append(current_sample) current_sample = [line] elif not line: # 空行 if current_sample: samples.append(current_sample) current_sample = [] else: current_sample.append(line) if current_sample: samples.append(current_sample) return samples def extract_process_memory( samples: List[List[str]], target: str, memory_col: str = "PSS" ) -> List[Tuple[float, float]]: # [(timestamp_sec, value_KB), ...] """ 从多个采样中提取目标进程的内存序列 target: 可以是 PID（str/int）或进程名（如 'com.example.app'） 返回：按采样顺序的时间戳（序号）和内存值列表 """ data = [] for i, sample_lines in enumerate(samples): # 尝试提取时间戳（若存在） timestamp = float(i) # 默认用序号作为相对时间 for line in sample_lines[:3]: # 查前3行找时间 m = re.search(r'time=(\d+\.\d+)', line) if m: timestamp = float(m.group(1)) break m = re.search(r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})', line) if m: try: dt = datetime.strptime(m.group(1), "%Y-%m-%d %H:%M:%S") timestamp = dt.timestamp() except ValueError: pass # 解析该采样内所有进程行 for line in sample_lines: proc = parse_procrank_line(line) if not proc: continue # 匹配 PID 或 cmdline if (str(proc["pid"]) == str(target)) or (target in proc["cmdline"]): val = proc.get(memory_col, 0.0) data.append((timestamp, val)) break # 每个采样只取第一个匹配进程（避免同名多实例干扰） return data def calculate_trends(data: List[Tuple[float, float]]) -> Dict[str, Any]: """计算内存趋势统计指标""" if not data: return {"error": "no data"} times, values = zip(*data) values = list(values) times = list(times) import numpy as np arr = np.array(values) t_arr = np.array(times) # 基础统计 stats = { "count": len(data), "min_KB": float(np.min(arr)), "max_KB": float(np.max(arr)), "mean_KB": float(np.mean(arr)), "std_KB": float(np.std(arr)), "total_growth_KB": float(arr[-1] - arr[0]) if len(arr) > 1 else 0.0, } # 线性拟合斜率（KB/秒） if len(arr) >= 2: slope, intercept = np.polyfit(t_arr, arr, 1) stats["slope_KB_per_sec"] = float(slope) stats["r_squared"] = float(np.corrcoef(t_arr, arr)[0, 1] ** 2) else: stats["slope_KB_per_sec"] = 0.0 stats["r_squared"] = 0.0 # 超时检测（连续 N 秒高于阈值） high_mem_periods = [] threshold = stats["mean_KB"] * 2.0 if stats["mean_KB"] > 0 else 50000 # 默认 50MB consecutive = 0 for i, v in enumerate(arr): if v > threshold: consecutive += 1 else: if consecutive > 5: # 超过 5 个采样点（假设 1s 一次，则 >5s） high_mem_periods.append({ "start_idx": i - consecutive, "duration_samples": consecutive, "peak_KB": float(max(arr[i-consecutive:i])) }) consecutive = 0 if consecutive > 5: high_mem_periods.append({ "start_idx": len(arr) - consecutive, "duration_samples": consecutive, "peak_KB": float(max(arr[-consecutive:])) }) stats["high_memory_periods"] = high_mem_periods return stats def plot_trend(data: List[Tuple[float, float]], process_name: str, output_png: str = None): """绘制内存趋势图""" if not data: print("⚠️ No data to plot.") return times, values = zip(*data) times = [t - times[0] for t in times] # 归零时间轴 plt.figure(figsize=(10, 5)) plt.plot(times, values, 'b-o', linewidth=2, markersize=4, label=f'{process_name} ({DEFAULT_MEMORY_COL})') plt.xlabel('Time (seconds from start)') plt.ylabel(f'Memory ({DEFAULT_MEMORY_COL}) (KB)') plt.title(f'Memory Trend for {process_name}') plt.grid(True, alpha=0.3) plt.legend() plt.tight_layout() if output_png: plt.savefig(output_png, dpi=150, bbox_inches='tight') print(f"✅ Plot saved to {output_png}") else: plt.show() def main(): parser = argparse.ArgumentParser(description="Parse procrank log and analyze memory trend") parser.add_argument("log_file", help="Path to procrank log file") parser.add_argument("-p", "--process", required=True, help="Process name (e.g., 'com.example.app') or PID (e.g., '1234')") parser.add_argument("-c", "--column", default=DEFAULT_MEMORY_COL, choices=["PSS", "RSS", "VSS", "USS"], help=f"Memory column to analyze (default: {DEFAULT_MEMORY_COL})") parser.add_argument("--csv", help="Export data to CSV file") parser.add_argument("--plot", help="Save plot to PNG file (e.g., trend.png)") parser.add_argument("--verbose", action="store_true", help="Print parsed raw data") args = parser.parse_args() # 读取日志 try: with open(args.log_file, "r", encoding="utf-8") as f: lines = f.readlines() except FileNotFoundError: print(f"❌ Error: File '{args.log_file}' not found.") sys.exit(1) # 分割采样 samples = split_log_into_samples(lines) print(f"🔍 Found {len(samples)} procrank samples.") # 提取目标进程内存序列 data = extract_process_memory(samples, args.process, args.column) print(f"📊 Extracted {len(data)} memory points for '{args.process}' ({args.column})") if args.verbose and data: print("\n📈 Raw data points:") for t, v in data: print(f" t={t:.1f}s → {v:.0f} KB") # 计算趋势 stats = calculate_trends(data) if "error" in stats: print(f"❌ {stats['error']}") sys.exit(1) # 打印结果 print("\n" + "="*50) print("📈 MEMORY TREND ANALYSIS REPORT") print("="*50) print(f"Target: {args.process}") print(f"Column: {args.column}") print(f"Samples: {stats['count']}") print(f"Min: {stats['min_KB']:.0f} KB") print(f"Max: {stats['max_KB']:.0f} KB") print(f"Mean: {stats['mean_KB']:.0f} KB") print(f"Std Dev: {stats['std_KB']:.0f} KB") print(f"Total Growth: {stats['total_growth_KB']:+.0f} KB") print(f"Slope: {stats['slope_KB_per_sec']:+.1f} KB/sec (R²={stats['r_squared']:.3f})") if stats["high_memory_periods"]: print(f"\n⚠️ HIGH MEMORY PERIODS DETECTED (>2x mean for >5s):") for p in stats["high_memory_periods"]: print(f" • From sample #{p['start_idx']} for {p['duration_samples']} samples, peak {p['peak_KB']:.0f} KB") else: print(f"\n✅ No prolonged high-memory periods detected.") # 导出 CSV if args.csv: with open(args.csv, "w", newline="") as f: writer = csv.writer(f) writer.writerow(["timestamp_sec", f"{args.column}_KB"]) writer.writerows(data) print(f"💾 Data exported to {args.csv}") # 绘图 if args.plot or not args.plot: plot_trend(data, args.process, args.plot) if __name__ == "__main__": main() ``` --- ### ✅ 三、【使用方法】 #### ▶️ 步骤 1：准备日志文件 `procrank.log` 确保日志包含多次 `procrank` 输出，例如： ```log # procrank -t 输出示例（带时间戳） time=1715234567.123 PID VSS RSS PSS USS cmdline 1234 123456K 78901K 45678K 34567K com.example.app 5678 98765K 54321K 23456K 12345K system_server time=1715234568.456 PID VSS RSS PSS USS cmdline 1234 130000K 82000K 48000K 36000K com.example.app ... ``` 或简单空行分隔： ```log PID VSS RSS PSS USS cmdline 1234 123456K 78901K 45678K 34567K com.example.app PID VSS RSS PSS USS cmdline 1234 130000K 82000K 48000K 36000K com.example.app ``` #### ▶️ 步骤 2：安装依赖（仅需 Matplotlib，可选） ```bash pip install matplotlib # 如需绘图；如只导 CSV，可跳过 ``` #### ▶️ 步骤 3：运行脚本 ```bash # 基础分析（打印报告） python parse_procrank.py procrank.log -p "com.example.app" # 指定分析 RSS 列 python parse_procrank.py procrank.log -p "1234" -c RSS # 导出 CSV + 保存图片 python parse_procrank.py procrank.log -p "com.example.app" --csv report.csv --plot trend.png # 查看原始解析数据（调试用） python parse_procrank.py procrank.log -p "com.example.app" --verbose ``` --- ### ✅ 四、【输出示例】 运行后你将看到类似： ``` 🔍 Found 12 procrank samples. 📊 Extracted 12 memory points for 'com.example.app' (PSS) ================================================== 📈 MEMORY TREND ANALYSIS REPORT ================================================== Target: com.example.app Column: PSS Samples: 12 Min: 42100 KB Max: 58900 KB Mean: 49250 KB Std Dev: 5120 KB Total Growth: +16800 KB Slope: +1420.3 KB/sec (R²=0.921) ✅ No prolonged high-memory periods detected. 💾 Data exported to report.csv ✅ Plot saved to trend.png ``` 并生成趋势图 `trend.png`：  --- ### ✅ 五、【进阶提示】 - ✅ **多进程对比**：运行多次脚本，分别提取 `com.example.app` 和 `system_server`，再用 Excel 合并分析； - ✅ **自动化监控**：结合 `adb shell procrank` 定时抓取，用此脚本每日生成报告； - ✅ **集成到 CI**：当 `slope_KB_per_sec > 1000` 且 `R² > 0.8` 时触发告警（内存持续泄漏）； - ✅ **Android 14 兼容**：`procrank` 输出列名可能微调，脚本已用正则容错，无需修改。 ---