Struct nu_system::ProcessInfo

pub struct ProcessInfo {

    pub pid: i32,
    pub command: String,
    pub ppid: i32,
    pub start_time: DateTime<Local>,
    pub cpu_info: CpuInfo,
    pub memory_info: MemoryInfo,
    pub disk_info: DiskInfo,
    pub user: SidName,
    pub groups: Vec<SidName>,
    pub priority: u32,
    pub thread: i32,
    pub interval: Duration,
    pub cmd: Vec<String>,
    pub environ: Vec<String>,
    pub cwd: PathBuf,
}

Fields

pid: i32

command: String

ppid: i32

start_time: DateTime<Local>

cpu_info: CpuInfo

memory_info: MemoryInfo

disk_info: DiskInfo

user: SidName

groups: Vec<SidName>

priority: u32

thread: i32

interval: Duration

cmd: Vec<String>

environ: Vec<String>

cwd: PathBuf

Implementations

impl ProcessInfo

pub fn pid(&self) -> i32

PID of process

Examples found in repository

examples/sys_demo.rs (line 18)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}

pub fn ppid(&self) -> i32

Parent PID of process

pub fn name(&self) -> String

Name of command

Examples found in repository

examples/sys_demo.rs (line 19)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}

pub fn command(&self) -> String

Full name of command, with arguments

pub fn environ(&self) -> Vec<String>

pub fn cwd(&self) -> String

pub fn status(&self) -> String

Get the status of the process

Examples found in repository

examples/sys_demo.rs (line 20)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}

pub fn cpu_usage(&self) -> f64

CPU usage as a percent of total

Examples found in repository

examples/sys_demo.rs (line 14)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}

pub fn mem_size(&self) -> u64

Memory size in number of bytes

Examples found in repository

examples/sys_demo.rs (line 22)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}

pub fn virtual_size(&self) -> u64

Virtual memory size in bytes

Examples found in repository

examples/sys_demo.rs (line 23)

fn main() {
    #[cfg(any(
        target_os = "android",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    {
        let cores = std::thread::available_parallelism()
            .map(|p| p.get())
            .unwrap_or(1);
        for run in 1..=10 {
            for proc in nu_system::collect_proc(std::time::Duration::from_millis(100), false) {
                if proc.cpu_usage() > 0.00001 {
                    println!(
                        "{} - {} - {} - {} - {:.2}% - {}M - {}M - {} procs",
                        run,
                        proc.pid(),
                        proc.name(),
                        proc.status(),
                        proc.cpu_usage() / cores as f64,
                        proc.mem_size() / (1024 * 1024),
                        proc.virtual_size() / (1024 * 1024),
                        cores,
                    )
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(1000));
        }
    }
}