Get current CPU usage on Deno - cpu-usage

Question

There are process.cpuUsage() function on NodeJS and Deno.memoryUsage() function to get memory usage on Deno
also there are a process module for Deno at https://deno.land/std#0.123.0/node/process.ts
but its not including something like .cpuUsage()
so is there are a way to get current cpu usage on Deno ?

Answer 1

At the time I write this answer, it's not natively possible to obtain sampled CPU load data in Deno.
If you want this data now, you can get it one of two ways:
Using the Foreign Function Interface API
Use the subprocess API
I'll provide a code sample below for how to get the data by installing Node.js and using the second method:
node_eval.ts:
type MaybePromise<T> = T | Promise<T>;
type Decodable = Parameters<TextDecoder['decode']>[0];
const decoder = new TextDecoder();
async function trimDecodable (decodable: MaybePromise<Decodable>): Promise<string> {
return decoder.decode(await decodable).trim();
}
/**
* Evaluates the provided script using Node.js (like
* [`eval`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval))
* and returns `stdout`.
*
* Uses the resolved version of `node` according to the host environemnt.
*
* Requires `node` to be available in `$PATH`.
* Requires permission `--allow-run=node`.
*/
export async function evaluateUsingNodeJS (script: string): Promise<string> {
const cmd = ['node', '-e', script];
const proc = Deno.run({cmd, stderr: 'piped', stdout: 'piped'});
const [{code}, stderr, stdout] = await Promise.all([
proc.status(),
trimDecodable(proc.stderrOutput()),
trimDecodable(proc.output()),
]);
if (code !== 0) {
const msg = stderr ? `\n${stderr}` : '';
throw new Error(`The "node" subprocess exited with a non-zero status code (${code}). If output was emitted to stderr, it is included below.${msg}`);
}
return stdout;
}
mod.ts:
import {evaluateUsingNodeJS} from './node_eval.ts';
export const cpuTimesKeys: readonly (keyof CPUTimes)[] =
['user', 'nice', 'sys', 'idle', 'irq'];
export type CPUTimes = {
/** The number of milliseconds the CPU has spent in user mode */
user: number;
/**
* The number of milliseconds the CPU has spent in nice mode
*
* `nice` values are POSIX-only.
* On Windows, the nice values of all processors are always `0`.
*/
nice: number;
/** The number of milliseconds the CPU has spent in sys mode */
sys: number;
/** The number of milliseconds the CPU has spent in idle mode */
idle: number;
/** The number of milliseconds the CPU has spent in irq mode */
irq: number;
};
export type CPUCoreInfo = {
model: string;
/** in MHz */
speed: number;
times: CPUTimes;
};
/**
* Requires `node` to be available in `$PATH`.
* Requires permission `--allow-run=node`.
*/
export async function sampleCPUsUsingNodeJS (): Promise<CPUCoreInfo[]> {
const script = `console.log(JSON.stringify(require('os').cpus()));`;
const stdout = await evaluateUsingNodeJS(script);
try {
return JSON.parse(stdout) as CPUCoreInfo[];
}
catch (ex) {
const cause = ex instanceof Error ? ex : new Error(String(ex));
throw new Error(`The "node" subprocess output couldn't be parsed`, {cause});
}
}
/**
* (Same as `CPUCoreInfo`, but) aliased in recognition of the transfromation,
* in order to provide JSDoc info regarding the transformed type
*/
export type TransformedCoreInfo = Omit<CPUCoreInfo, 'times'> & {
/** Properties are decimal percentage of total time */
times: Record<keyof CPUCoreInfo['times'], number>;
};
/** Converts each time value (in ms) to a decimal percentage of their sum */
export function coreInfoAsPercentages (coreInfo: CPUCoreInfo): TransformedCoreInfo {
const timeEntries = Object.entries(coreInfo.times) as [
name: keyof CPUCoreInfo['times'],
ms: number,
][];
const sum = timeEntries.reduce((sum, [, ms]) => sum + ms, 0);
for (const [index, [, ms]] of timeEntries.entries()) {
timeEntries[index][1] = ms / sum;
}
const times = Object.fromEntries(timeEntries) as TransformedCoreInfo['times'];
return {...coreInfo, times};
}
example.ts:
import {
coreInfoAsPercentages,
cpuTimesKeys,
sampleCPUsUsingNodeJS,
type CPUCoreInfo,
} from './mod.ts';
function anonymizeProcessorAttributes <T extends CPUCoreInfo>(coreInfoArray: T[]): T[] {
return coreInfoArray.map(info => ({
...info,
model: 'REDACTED',
speed: NaN,
}));
}
// Get the CPU info
const cpuCoreInfoArr = await sampleCPUsUsingNodeJS();
// Anonymizing my personal device details (but you would probably not use this)
const anonymized = anonymizeProcessorAttributes(cpuCoreInfoArr);
// JSON for log data
const jsonLogData = JSON.stringify(anonymized);
console.log(jsonLogData);
// Or, for purely visual inspection,
// round the percentages for greater scannability...
const roundedPercentages = anonymized.map(coreInfo => {
const asPercentages = coreInfoAsPercentages(coreInfo);
for (const key of cpuTimesKeys) {
asPercentages.times[key] = Math.round(asPercentages.times[key] * 100);
}
return asPercentages;
});
// and log in tabular format
console.table(roundedPercentages.map(({times}) => times));
In the console:
% deno run --allow-run=node example.ts
[{"model":"REDACTED","speed":null,"times":{"user":2890870,"nice":0,"sys":2290610,"idle":17913530,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":218270,"nice":0,"sys":188200,"idle":22687790,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":2509660,"nice":0,"sys":1473010,"idle":19111680,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":221630,"nice":0,"sys":174140,"idle":22698480,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":2161140,"nice":0,"sys":1086970,"idle":19846200,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":221800,"nice":0,"sys":157620,"idle":22714800,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":1905230,"nice":0,"sys":897140,"idle":20291910,"irq":0}},{"model":"REDACTED","speed":null,"times":{"user":224060,"nice":0,"sys":146460,"idle":22723700,"irq":0}}]
┌───────┬──────┬──────┬─────┬──────┬─────┐
│ (idx) │ user │ nice │ sys │ idle │ irq │
├───────┼──────┼──────┼─────┼──────┼─────┤
│ 0 │ 13 │ 0 │ 10 │ 78 │ 0 │
│ 1 │ 1 │ 0 │ 1 │ 98 │ 0 │
│ 2 │ 11 │ 0 │ 6 │ 83 │ 0 │
│ 3 │ 1 │ 0 │ 1 │ 98 │ 0 │
│ 4 │ 9 │ 0 │ 5 │ 86 │ 0 │
│ 5 │ 1 │ 0 │ 1 │ 98 │ 0 │
│ 6 │ 8 │ 0 │ 4 │ 88 │ 0 │
│ 7 │ 1 │ 0 │ 1 │ 98 │ 0 │
└───────┴──────┴──────┴─────┴──────┴─────┘

Answer 2

You can use https://deno.land/std#0.123.0/node/os.ts where cpus() gives CPUCoreInfo[]