在对 Electron 应用的问题进行分析时，相关的系统运行信息有时也是必不可少的，所以自然就有了系统基础信息收集和运行性能监测的需求。

Electron 中的原生能力基于 Node.js，所以 Electron 应用的系统数据收集大多数是基于 Node.js 提供的能力实现。在 Node.js 应用中，主要可以通过 process 和 os 模块获取各种系统相关的信息，其中又可分为静态基础信息和动态变化的运行时信息。

下面对数据统计分析可能用到的信息进行简单的介绍。

1. Node.js 中的 process 模块提供的信息

• process.pid 当前进程的 PID
• process.ppid 当前进程的父进程的 PID
• process.platform 返回标识运行 Node.js 进程的操作系统平台的字符串
• process.cwd() 返回应用进程的当前工作目录
• process.arch 其编译 Node.js 二进制文件的操作系统 CPU 架构。
• process.argv 返回数组，其中包含启动 Node.js 进程时传入的命令行参数。
• process.versions 返回 Node.js 及其依赖项的版本信息
• process.env 应用运行环境的环境变量
• process.cpuUsage([previousValue]) 在具有属性 user 和 system 的对象中返回当前进程的用户和系统 CPU 时间使用情况，其值为微秒值
• process.memoryUsage() 返回描述 Node.js 进程的内存使用量（以字节为单位）的对象
  • .heapTotal 和 .heapUsed 指的是 V8 的内存使用量。
  • .external 指的是绑定到 V8 管理的 JavaScript 对象的 C++ 对象的内存使用量。
  • .rss 常驻集大小，是进程在主内存设备（即总分配内存的子集）中占用的空间量，包括所有 C++ 和 JavaScript 对象和代码。
  • .arrayBuffers 是指为 ArrayBuffer 和 SharedArrayBuffer 分配的内存，包括所有 Node.js Buffer。 这也包含在 external 值中。 当 Node.js 被用作嵌入式库时，此值可能为 0，因为在这种情况下可能不会跟踪 ArrayBuffer 的分配。
• process.resourceUsage() 返回当前进程的资源使用情况
  • Node.js@12.6+ / Electron@7.x+ 才会有
• process.uptime() 返回当前 Node.js 进程已经运行的秒数

2. Electron 中的 process 模块扩展的信息

• process.resourcesPath 资源目录的路径。可以统计应用被安装或启动运行的位置
• process.type 当前进程的类型。可以是： browser、renderer、worker
• process.getCPUUsage() 返回当前进程的 CPU 使用率
• process.getHeapStatistics() 返回包含 V8 堆统计的对象。所有数据值以 KB 为单位
• process.getSystemMemoryInfo() 返回一个对象，提供整个系统的内存使用统计。统计值单位为 KB
• process.getProcessMemoryInfo() 返回一个对象，提供当前进程的内存使用统计。统计值单位为 KB
• process.getBlinkMemoryInfo()
  • 返回带有Blink内存信息的对象。 可以用于调试渲染/DOM相关内存问题。所有值都以KB为单位
  • 在 Electron@7+ 版本增加的方法

3. electron 提供的信息统计方法

• electron.app.getAppMetrics()
  • 返回 ProcessMetric[]: 包含所有与应用相关的进程的内存和CPU的使用统计的 ProcessMetric 对象的数组。
  • 返回值在 electron@7+ 才新增 memory 字段，包含所有子进程的内存使用统计
• electron.screen.getAllDisplays() 返回一个窗口数组Display[]，表示当前可用的显示器窗口。

4. Node.js 中的 os 模块提供的信息

• os.platform() 操作系统平台的字符串标识，同 process.platform
• os.hostname() 主机名
• os.homedir() 用户主目录
• os.type() 操作系统内核名
• os.endianness() 返回标识为其编译 Node.js 二进制文件的 CPU 的字节序的字符串。大端序 BE、小端序 LE。
• os.cpus() 返回包含有关每个逻辑 CPU 内核的信息的对象数组。
• os.uptime() 以秒为单位返回系统正常运行时间。同 process.uptime()
• os.totalmem() 内存总量。同 process.getSystemMemoryInfo().total
• os.freemem() 空闲内存大小。同 process.getSystemMemoryInfo().free
• os.loadavg() 1、5 和 15 分钟的平均负载。windows 始终为 0
• os.release() 以字符串形式返回操作系统的版本编号
• os.tmpdir() 以字符串形式返回操作系统默认的临时文件的目录
• os.networkInterfaces() 已分配网址的网卡信息
• os.userInfo([options]) 返回有关当前有效用户的信息

5. 数据收集与分析

基于以上各 API 提供的能力，结合在实际测试中的实践经验，我们得出一些经验总结如下。

数据分类。我们将统计收集的信息可以分为静态基础信息和动态信息。静态基础信息即不会变化的数据，只需在初始化时统计并记录一次即可。静态信息可以用于分析具体的应用运行环境状态。动态信息即每次获取都可能会变化的数据。对应用的性能分析主要基于动态信息的定时监测与收集。

数据格式化。收集到的原始数据不够直观，可用于数据统计，但在直接显示上则需要做一定的预格式化处理。主要包括时间消耗、内存大小、CPU使用率三类数据，设计对应的格式化辅助函数，在取得数据后进行预处理即可。具体实现见下文代码示例。

各 API 提供的数据很多，在基于应用性能的数据收集与分析上，动态监测的数据主要为各进程的 CPU 使用率和内存使用量。绝大部分数据在主进程收集即可。

对于动态变化的数据，需按一定策略间隔性的收集，然后可以导出到针对性的分析平台，画出动态变化的曲线来观测分析。

6. Node.js 系统信息统计的实现代码参考

综合以上的信息收集与分析，简单实现了一个 SysInfoStats 统计类用于定时收集系统信息。具体的代码参考如下：

import os from 'os';
import { app, screen } from 'electron';
/** 将秒转换为日期 */
function formatSeconds(seconds: number) {
seconds = seconds | 0;
const day = (seconds / (3600 * 24)) | 0;
const hours = ((seconds - day * 3600) / 3600) | 0;
const minutes = ((seconds - day * 3600 * 24 - hours * 3600) / 60) | 0;
const second = seconds % 60;
return [day, hours, minutes, second].map(d => String(d).padStart(2, '0')).join(':');
}
function formatMem(mem: number) {
if (mem > 1 << 30) return (mem / (1 << 30)).toFixed(2) + 'G';
if (mem > 1 << 20) return (mem / (1 << 20)).toFixed(2) + 'M';
if (mem > 1 << 10) return (mem / (1 << 10)).toFixed(2) + 'KB';
return mem + 'B';
}
function formatMemForObject<t>(obj: T, unit = 1): Record<keyof T, string> {
const d = {} as Record</keyof><keyof T, string> ;
Object.keys(obj).forEach(k => {
d[k] = formatMem(Number(obj[k]) * unit);
});
return d;
}
class SysInfoStats {
/** 基础信息，不会变化的 */
public baseInfo = {
/** 当前进程的 PID */
pid: process.pid,
/** 当前进程的父进程的 PID */
ppid: process.ppid,
/** 程序启动位置 */
cwd: process.cwd(),
/** 主机名 */
hostname: os.hostname(),
/** 用户主目录 */
homedir: os.homedir(),
/** 系统架构 */
arch: process.arch,
/** 系统平台 Win32 */
platform: process.platform || os.platform(),
/** 操作系统内核名 Windows_NT */
type: os.type(),
/** 系统版本号 */
release: os.release(),
/** electron 相关的版本信息 */
versions: process.versions,
/** 字节序 */
endianness: os.endianness(),
/** 网卡信息 */
get networkInterfaces() {
return os.networkInterfaces();
},
/** 显示器信息 **/
get allDisplays() {
return screen.getAllDisplays();
},
/** 命令行参数 */
argv: process.argv,
/** 环境变量 */
env: process.env,
};
/** 实时动态变更的信息 */
public dynamicInfo = {
// /** 内存总量，同 sysMemoryInfo.total */
// totalmem: os.totalmem(),
// /** 空闲内存，同 sysMemoryInfo.free */
// freemem: os.freemem(),
/** 系统的正常运行时间（以秒为单位） */
get uptime() {
return process.uptime();
},
/** 1、5 和 15 分钟的平均负载。windows 始终为 0 */
get loadavg() {
return os.loadavg();
},
/** memory usage statistics about the current process */
processMemoryInfo: null as Electron.ProcessMemoryInfo,
/** memory usage statistics about the entire system. */
get sysMemoryInfo() {
return formatMemForObject(process.getSystemMemoryInfo(), 1024);
},
/** V8 heap statistics. KB */
get heapStatistics() {
const r = process.getHeapStatistics();
return formatMemForObject(r, 1024);
},
/** 内存使用量（以字节为单位） */
get memoryUsage() {
const r = process.memoryUsage();
return formatMemForObject(r);
},
/** cpu 使用率 */
get getCPUUsage() {
return process.getCPUUsage();
},
/** 各子进程 cpu 占用率 */
getAppMetrics() {
const appMetrics = app.getAppMetrics();
return appMetrics.map(item => {
return {
pid: item.pid,
type: item.type,
percentCPUUsage: Number(item.cpu.percentCPUUsage).toFixed(2) + '%',
// electron@7+ 才有 item.memory 信息
// memory: formatMemForObject(item.memory, 1024),
}
});
},
/** cpu 信息 */
get cpus() {
return os.cpus();
},
/** 资源占用情况 -- electron@7.x+ 才有 */
// get resourceUsage() {
//    return process.resourceUsage();
// },
};
constructor() {
this.statsBase();
// this.statsDynamic();
this.interval();
}
/** 打印并写入日志 */
private printLog(...args) {
logger.log('[sysstats]', ...args);
}
private intervalTimer: NodeJS.Timeout;
/**
* 执行定时统计
* @param intervalTime 定时器时间，默认为 5 分钟。小于 1000 表示停止
*/
public interval(intervalTime = 5 * 60 * 1000) {
clearTimeout(this.intervalTimer);
const cInterval = Number((process.env as HippoEnv).HIPPO_SYSSTATS_INTERVAL);
if (cInterval) intervalTime = cInterval;
if (intervalTime > 1000) {
this.intervalTimer = setInterval(() => this.statsDynamic(), intervalTime);
}
}
/** 基本信息收集与打印 */
public statsBase() {
const msgList: string[] = [];
const { baseInfo } = this;
msgList.push(`\ncwd: ${baseInfo.cwd}`);
// msgList.push(`Node.js 版本：${baseInfo.versions.node}`);
msgList.push(`cpu架构：${baseInfo.arch}`);
msgList.push('操作系统内核：' + baseInfo.type);
msgList.push('平台：' + baseInfo.platform);
msgList.push('主机名：' + baseInfo.hostname);
msgList.push('主目录：' + baseInfo.homedir);
const networkInterfaces = baseInfo.networkInterfaces;
msgList.push('*****网卡信息*******');
for (const key in networkInterfaces) {
const list = networkInterfaces[key];
msgList.push(`${key}:`);
list.forEach((obj, idx) => {
msgList.push(`[${idx}][${obj.cidr}]:`);
msgList.push(`IP: ${obj.address}`);
msgList.push(`NETMASK: ${obj.netmask}`);
msgList.push(`MAC: ${obj.mac}`);
msgList.push(`family: ${obj.family}`);
// msgList.push(`远程访问：${obj.internal ? '否' : '是'}\n`);
});
}
this.printLog('[base][overview]', msgList.join('\n'));
this.printLog('[base][json]\n', this.baseInfo);
return this.baseInfo;
}
/**
* 实时系统信息收集与打印
* @param printBase 是否打印固定不变的基础信息。构造函数内默认执行过一次，默认 false
* @returns
*/
public async statsDynamic(label = '', printBase = false) {
if (printBase) this.statsBase();
const sysInfo = this.dynamicInfo;
const msgList: string[] = [];
msgList.push('\n运行时长：' + formatSeconds(sysInfo.uptime));
// const sysMemoryInfo = sysInfo.sysMemoryInfo;
// msgList.push('内存大小：' + sysMemoryInfo.total);
// msgList.push('空闲内存：' + formatMem(sysMemoryInfo.free));
// electron@7+ 才有
// msgList.push('userCPUTime：' + formatSeconds(sysInfo.resourceUsage.userCPUTime / (1000 * 1000)));
// msgList.push('systemCPUTime：' + formatSeconds(sysInfo.resourceUsage.systemCPUTime / (1000 * 1000)));
// 内存用量
const memoryUsage = sysInfo.memoryUsage;
msgList.push('*****memoryUsage*******');
msgList.push(`V8 内存总量:\t ${memoryUsage.heapTotal}`);
msgList.push(`V8 使用量:\t ${memoryUsage.heapUsed}`);
msgList.push(`C++对象内存:\t ${memoryUsage.external}`);
msgList.push(`主内存设备占用:\t ${memoryUsage.rss}`);
// cpu
const cpus = sysInfo.cpus;
msgList.push('*****cpu信息*******');
cpus.forEach((cpu, idx, _arr) => {
const times = cpu.times;
const useageRate = `${((1 - times.idle / (times.idle + times.user + times.nice + times.sys + times.irq)) * 100).toFixed(2)}%`;
msgList.push([`cpu-${idx}：`, `使用率：${useageRate}`, `型号：${cpu.model}`, `频率：${cpu.speed}MHz`].join('  '));
});
sysInfo.processMemoryInfo = await this.getProcessMemoryInfo();
this.printLog('[dynamicInfo][overview]' + label, msgList.join('\n'));
this.printLog('[dynamicInfo][json]\n', sysInfo);
return msgList;
}
/** 获取当前进程的内存占用信息 */
public async getProcessMemoryInfo() {
const processMemoryInfo = await process.getProcessMemoryInfo();
Object.keys(processMemoryInfo).forEach(k => {
processMemoryInfo[k] = formatMem(processMemoryInfo[k] * 1024);
});
this.dynamicInfo.processMemoryInfo = processMemoryInfo;
return processMemoryInfo;
}
/** 获取 ip 和 mac 地址（可远程访问的） */
public getIPAndMac() {
const result = [] as { ip: string; mac: string; family: "IPv4" | "IPv6" }[];
Object.keys(this.baseInfo.networkInterfaces).forEach(key => {
const item = this.baseInfo.networkInterfaces[key];
item.forEach(d => {
if (!d.internal) {
result.push({ ip: d.address, mac: d.mac, family: d.family });
}
});
});
return result;
}
}

7. 相关参考

• Node.js process API
• Node.js process API(中文)
• Electron process 文档