sys-lib 0.5.1

System facts for Rust services: OS, CPU, memory, disks, network, host, this process, virtualization, power, and device identity, container-aware by default, plus build info, instance info, and a process guard. No subprocesses, zero third-party dependencies.
Documentation

Scope

Static facts read once and cached (OS name and version, CPU model, core counts, CPU features, caches, topology, virtualization, form factor); live readings read fresh on every call with no allocation for single values (memory, swap, uptime, load, disk space, this process's memory and CPU time); caller-owned samplers for values that need two readings (CPU usage, network rates); the boot kit (build info, instance info, process guard); and an opt-in device id derived with a keyed hash, so raw hardware identifiers never leave the library. It does not inspect other processes, change system settings, or run in the background.

Quick start

Cargo's rename makes the crate sys in your code:

[dependencies]
sys = { package = "sys-lib", version = "0.5" }

Tier 1 is one plain call per fact. Static facts are read once and cached, so every later call costs about a nanosecond:

println!("{}", sys::os::name());          // "Ubuntu 24.04.1 LTS", "macOS 15.1 Sequoia", "Windows 11 Pro"
println!("{}", sys::os::distro());        // "Ubuntu"; "Windows" and "macOS" elsewhere
println!("{}", sys::cpu::name());         // "AMD Ryzen 9 7950X"
println!("{} cores, {} threads", sys::cpu::physical(), sys::cpu::logical());
println!("{} usable here", sys::cpu::available());   // the container's quota, not the host's count
println!("{}", sys::host::name()?);       // "build-07"
if sys::cpu::is_64bit() && sys::os::is_like("debian") { /* ... */ }

// Live readings: read now, container-aware.
println!("{} of {} used", sys::mem::used()?, sys::mem::total()?);   // "41.2 GiB of 125.6 GiB" (the cgroup's limit inside a container)
println!("{}", sys::cpu::used()?);        // "12.4%" (blocks for 100 ms)
let t = sys::net::traffic()?;             // blocks 1 s
println!("down {} up {}", t.download, t.upload);   // "down 12.5 MiB/s up 1.2 MiB/s"
println!("{} free", sys::disk::space("/var/lib/hive")?.available);

A monitor keeps samplers instead of blocking: each is owned by the caller, never sleeps, and allocates nothing per sample:

let mut cpu = sys::cpu::Sampler::new()?;
let mut net = sys::net::Sampler::new()?;
loop {
    std::thread::sleep(std::time::Duration::from_secs(5));
    let (u, t) = (cpu.sample()?, net.sample()?);
    println!("cpu {} down {} up {}", u.used(), t.download, t.upload);
    if let Some(p) = sys::mem::pressure()? {
        if p.level >= sys::PressureLevel::Warning { /* trim caches */ }
    }
}

The boot kit, for a long-running service's first milliseconds:

fn main() -> Result<(), sys::Error> {
    // One copy only, private files by default, enough file descriptors.
    // Before any file is opened and before threads start.
    let _guard = sys::process::guard("site")?;

    let build = sys::build_info!();       // needs `sys::build::emit()` in build.rs
    let instance = sys::Instance::start();
    println!("{build}");                  // site 1.4.0 (9db9e36, release, built 2026-10-21T18:02:11Z)
    println!("{instance}");               // 01J9ZQ4M8T6Y2K5V3W1X7R0B9C build-07 pid 4821 up 0s
    println!("{}", build.public());       // site 1.4.0: safe for a public health endpoint

    let workers = sys::cpu::available();  // size the pool to what the cgroup allows
    // ...
    Ok(())
}
// build.rs
fn main() {
    sys::build::emit();
}

Tier 2 adds detail behind the same modules (sys::os::info(), sys::os::os_release(), sys::process::Guard::builder(..)); errors say what failed and what to do, and a fact the OS does not expose is Error::Unsupported, never a guess.

What it runs on

let v = sys::virt::detect();            // VM, container, WSL, Kubernetes, each with its evidence
println!("{}", sys::summary());         // the facts for a log line, with no identifiers

// With the `device-id` feature:
let id = sys::device::id("com.example.app")?;   // keyed, so applications cannot correlate it

Planned for 0.6

let r = sys::readiness::report(sys::readiness::Profile::Database); // is this host fit to serve?

The complete planned API, with the version each item arrives in, is in docs/API.md; where every value comes from on each operating system is in docs/SOURCES.md. See dev/PLAN.md for the full scope, what is deliberately left to other crates, and the decision log.

Contributing

See dev/DIRECTIVES.md for engineering standards and the definition of done. Before a PR: cargo fmt --all, cargo clippy --all-targets --all-features -- -D warnings, and cargo test --all-features must be clean.