Tumortisch-Dist/resources/app/node_modules/electron-process-reporter/lib/index.d.ts
2021-06-15 16:00:08 +02:00

108 lines
3.9 KiB
TypeScript

import { Observable } from 'rxjs';
export interface onProcessMetricsOptions {
/** in ms */
samplingInterval?: number;
}
export interface PidUsage {
cpu: number;
memory: number;
pid: number;
ppid: number;
ctime: number;
elapsed: number;
timestamp: number;
}
export declare const getAppUsage: (pid: number) => Promise<PidUsage[]>;
/**
* Returns an Observable that emits Electron.ProcessMetric[] on a regular interval.
*
* For a given `app` and a given `samplingInterval`, the returned observable is shared
* for performance reasons.
*
* options.samplingInterval = 1000 (1s) by default
* @param app
* @param options
*/
export declare const onProcessMetrics: (app: Electron.App, options: onProcessMetricsOptions) => Observable<Electron.ProcessMetric[]>;
/**
* Returns an Rx.Observable that emits `PidUsage[]` every `options.samplingInterval` ms.
*
* For a given `pid` and a given `samplingInterval`, the returned observable is shared
* for performance reasons.
* `pid` is the root of the process tree.
*
* @param pid
* @param {object} options
* @param {number} options.samplingInterval - 1000 (1s) by default
*
* @example
* - pid: main process
* - rendererPid1: renderer process
* - rendererPid2: renderer process
*/
export declare const onProcessTreeMetricsForPid: (pid: number, options: onProcessMetricsOptions) => Observable<PidUsage[]>;
export interface ExtendedProcessMetric extends Electron.ProcessMetric {
webContents?: {
type: string;
id: number;
pid: number;
URL: string;
URLDomain: string;
}[];
}
/**
* Returns an Rx.Observable that emits reports of `ExtendedProcessMetric`
* every `options.samplingInterval` ms.
*
* Default `options.samplingInterval` = 1000ms
*
* Compared to `onProcessMetrics` it adds data on the `webContents` associated
* to the given process.
*
* @param app the electron app instance
* @param options
*/
export declare const onExtendedProcessMetrics: (app: Electron.App, options?: onProcessMetricsOptions) => Observable<ExtendedProcessMetric[]>;
export interface onExcessiveCPUUsageOptions extends onProcessMetricsOptions {
/**Number of samples to consider */
samplesCount?: number;
/**CPU usage percent minimum to consider a sample exceeds CPU usage */
percentCPUUsageThreshold?: number;
}
/**
* Will emit an array of `PidUsage` when a process of the tree exceeds the
* `options.percentCPUUsageThreshold` on more than `options.samplesCount`
* samples.
* It monitors the whole tree of pids, starting from `childPid`.
* The reason behind this is that the `process.pid` of the main process is at the same
* level as all renderers.
* So we fetch their common ancestor, which is the `ppid` of the main process.
* The parent pid of `childPid` is not part of the end result
* (that way, we monitor the same processes as `getAppMetrics`).
*
* In opposite to onExcessiveCPUUsage, onExcessiveCPUUsageInProcessTree does not use
* Electron's internal measurement but rather use `pidusage`, a cross-platform
* process cpu % and memory usage of a PID. It is known to have lower pressure on CPU.
* Also, as this leverage `pidusage`, the measures on Windows can be considered
* as not accurate.
*
* Default `options.samplesCount` = 10
* Default `options.percentCPUUsageThreshold` = 80
*
* @param pid - the pid of the main process
* @param options
*/
export declare const onExcessiveCPUUsageInProcessTree: (pid: number, options: onExcessiveCPUUsageOptions) => Observable<PidUsage[]>;
/**
* Will emit an array `ExtendedProcessMetric` when a process exceeds the
* `options.percentCPUUsageThreshold` on more than `options.samplesCount`
* samples.
*
* Default `options.samplesCount` = 10
* Default `options.percentCPUUsageThreshold` = 80
*
* @param app the electron app instance
* @param options
*/
export declare const onExcessiveCPUUsage: (app: Electron.App, options: onExcessiveCPUUsageOptions) => Observable<ExtendedProcessMetric[]>;