peek-core 1.0.0

Core process intelligence library for the Peek tool on Linux
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// Linux-only implementation using /proc and procfs.

use crate::{PeekError, ProcessInfo, Result};
use chrono::{DateTime, Local};
use kernel_explainer::states::state_description;
use procfs::process::Process;

pub fn collect_process_impl(pid: i32, sample_cpu: bool) -> Result<ProcessInfo> {
    let process = Process::new(pid).map_err(|err| match err {
        procfs::ProcError::NotFound(_) => PeekError::NotFound(pid),
        procfs::ProcError::Io(e, _) => PeekError::ProcIo { pid, source: e },
        other => PeekError::ProcParse {
            pid,
            msg: other.to_string(),
        },
    })?;

    let stat = process.stat().map_err(|e| PeekError::ProcParse {
        pid,
        msg: e.to_string(),
    })?;
    let status = process.status().map_err(|e| PeekError::ProcParse {
        pid,
        msg: e.to_string(),
    })?;
    let statm = process.statm().map_err(|e| PeekError::ProcParse {
        pid,
        msg: e.to_string(),
    })?;

    let name = stat.comm.clone();
    let cmdline = process
        .cmdline()
        .ok()
        .filter(|v| !v.is_empty())
        .map(|v| v.join(" "))
        .unwrap_or_else(|| name.clone());

    let exe = process
        .exe()
        .ok()
        .and_then(|p| p.into_os_string().into_string().ok());

    let state = state_description(stat.state);
    let ppid = stat.ppid;
    let uid = status.ruid;
    let gid = status.rgid;

    let started_at = boot_time().map(|boot| {
        let ticks = procfs::ticks_per_second();
        let secs = stat.starttime / ticks;
        let nanos = (stat.starttime % ticks) * 1_000_000_000 / ticks;
        boot + chrono::Duration::seconds(secs as i64) + chrono::Duration::nanoseconds(nanos as i64)
    });

    let threads = stat.num_threads as i32;
    let vm_size_kb = statm.size * 4;
    let rss_kb = statm.resident * 4;

    let cpu_percent = if sample_cpu {
        super::resources::sample_cpu(pid)
    } else {
        None
    };

    Ok(ProcessInfo {
        pid,
        name,
        cmdline,
        exe,
        state,
        ppid,
        uid,
        gid,
        started_at,
        threads,
        vm_size_kb,
        rss_kb,
        pss_kb: None,
        swap_kb: None,
        cpu_percent,
        io_read_bytes: None,
        io_write_bytes: None,
        fd_count: None,
        kernel: None,
        network: None,
        open_files: None,
        env_vars: None,
        process_tree: None,
        gpu: None,
    })
}

/// Cached boot time from /proc/stat. Read once; boot time does not change.
fn boot_time() -> Option<DateTime<Local>> {
    use std::sync::OnceLock;
    static CACHED: OnceLock<Option<DateTime<Local>>> = OnceLock::new();
    *CACHED.get_or_init(|| procfs::boot_time().ok())
}