Systemstat

https://docs.rs/systemstat/0.2.6
Admin
Systemstat is a Rust library that provides access to system information such as CPU load, mounted...
Tokens:97,060
Snippets:637
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### BTreeMap Examples

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Illustrative examples demonstrating how to use the BTreeMap, including insertion, retrieval, removal, and iteration.

```APIDOC
## §Examples

### Basic Usage
```rust
use std::collections::BTreeMap;

let mut movie_reviews = BTreeMap::new();

movie_reviews.insert("Office Space",       "Deals with real issues in the workplace.");
movie_reviews.insert("Pulp Fiction",       "Masterpiece.");
movie_reviews.insert("The Godfather",      "Very enjoyable.");
movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot.");

if !movie_reviews.contains_key("Les Misérables") {
    println!("We've got {} reviews, but Les Misérables ain't one.",
             movie_reviews.len());
}

movie_reviews.remove("The Blues Brothers");

let to_find = ["Up!", "Office Space"];
for movie in &to_find {
    match movie_reviews.get(movie) {
       Some(review) => println!("{movie}: {review}"),
       None => println!("{movie} is unreviewed.")
    }
}

println!("Movie review: {}", movie_reviews["Office Space"]);

for (movie, review) in &movie_reviews {
    println!("{movie}: \"{review}\"");
}
```

### Initialization from Array
```rust
use std::collections::BTreeMap;

let solar_distance = BTreeMap::from([
    ("Mercury", 0.4),
    ("Venus", 0.7),
    ("Earth", 1.0),
    ("Mars", 1.5),
]);
```
```

--------------------------------

### Creating a Scraped Example in Rust

Source: https://docs.rs/systemstat/0.2.6/scrape-examples-help.html

This demonstrates how to create an example file that calls a documented item from another crate. This code will be scraped by Rustdoc.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### GET /boot-time

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves the system's boot time.

```APIDOC
## GET /boot-time

### Description
Retrieves the timestamp of when the system was last booted.

### Method
GET

### Endpoint
/boot-time

### Response
#### Success Response (200)
- **boot_time** (string) - The system boot time (e.g., ISO 8601 format).

#### Response Example
```json
{
  "boot_time": "2023-10-27T10:00:00Z"
}
```
```

--------------------------------

### GET /mounts

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves a list of all mounted filesystems.

```APIDOC
## GET /mounts

### Description
Retrieves a list of all mounted filesystems on the system.

### Method
GET

### Endpoint
/mounts

### Response
#### Success Response (200)
- **mounts** (array) - A list of filesystem mount information.
  - **fs_mounted_from** (string) - The source of the mount.
  - **fs_type** (string) - The type of the filesystem.
  - **fs_mounted_on** (string) - The mount point path.
  - **avail** (string) - The available space.
  - **total** (string) - The total space.

#### Response Example
```json
{
  "mounts": [
    {
      "fs_mounted_from": "/dev/sda1",
      "fs_type": "ext4",
      "fs_mounted_on": "/",
      "avail": "100GB",
      "total": "200GB"
    }
  ]
}
```
```

--------------------------------

### Systemstat example: Gathering system information

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.DelayedMeasurement.html

This example demonstrates how to use the `systemstat` crate to gather various system statistics including mounts, block devices, network interfaces, battery status, memory, swap, load average, uptime, boot time, CPU load, CPU temperature, and socket statistics. It includes error handling for each operation.

```rust
7fn main() {
    let sys = System::new();

    match sys.mounts() {
        Ok(mounts) => {
            println!("\nMounts:");
            for mount in mounts.iter() {
                println!("{} ---{}---> {} (available {} of {})",
                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
            }
        }
        Err(x) => println!("\nMounts: error: {}", x)
    }

    match sys.mount_at("/") {
        Ok(mount) => {
            println!("\nMount at /:");
            println!("{} ---{}---> {} (available {} of {})",
                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
        }
        Err(x) => println!("\nMount at /: error: {}", x)
    }

    match sys.block_device_statistics() {
        Ok(stats) => {
            for blkstats in stats.values() {
                println!("{}: {:?}", blkstats.name, blkstats);
            }
        }
        Err(x) => println!("\nBlock statistics error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetworks:");
            for netif in netifs.values() {
                println!("{} ({:?})", netif.name, netif.addrs);
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetwork interface statistics:");
            for netif in netifs.values() {
                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.battery_life() {
        Ok(battery) =>
            print!("\nBattery: {}%, {}h{}m remaining",
                   battery.remaining_capacity*100.0,
                   battery.remaining_time.as_secs() / 3600,
                   battery.remaining_time.as_secs() % 60),
        Err(x) => print!("\nBattery: error: {}", x)
    }

    match sys.on_ac_power() {
        Ok(power) => println!(', AC power: {}', power),
        Err(x) => println!(', AC power: error: {}', x)
    }

    match sys.memory() {
        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
        Err(x) => println!("\nMemory: error: {}", x)
    }

    match sys.swap() {
        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
        Err(x) => println!("\nSwap: error: {}", x)
    }

    match sys.load_average() {
        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
        Err(x) => println!("\nLoad average: error: {}", x)
    }

    match sys.uptime() {
        Ok(uptime) => println!("\nUptime: {:?}", uptime),
        Err(x) => println!("\nUptime: error: {}", x)
    }

    match sys.boot_time() {
        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
        Err(x) => println!("\nBoot time: error: {}", x)
    }

    match sys.cpu_load_aggregate() {
        Ok(cpu)=> {
            println!("\nMeasuring CPU load...");
            thread::sleep(Duration::from_secs(1));
            let cpu = cpu.done().unwrap();
            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
        },
        Err(x) => println!("\nCPU load: error: {}", x)
    }

    match sys.cpu_temp() {
        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
        Err(x) => println!("\nCPU temp: {}", x)
    }

    match sys.socket_stats() {
        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
        Err(x) => println!("\nSystem socket statistics: error: {}", x)
    }
}

```

--------------------------------

### GET /uptime

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves the system's uptime.

```APIDOC
## GET /uptime

### Description
Retrieves the amount of time the system has been running since the last boot.

### Method
GET

### Endpoint
/uptime

### Response
#### Success Response (200)
- **uptime** (string) - The system uptime duration (e.g., in seconds or a formatted string).

#### Response Example
```json
{
  "uptime": "10 days, 5 hours, 30 minutes"
}
```
```

--------------------------------

### Create BTreeMap from Array Example

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Demonstrates creating a BTreeMap from a fixed-size array using `BTreeMap::from` and the `into()` method.

```rust
use std::collections::BTreeMap;

let map1 = BTreeMap::from([(1, 2), (3, 4)]);
let map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);
```

--------------------------------

### GET /swap

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves swap space usage statistics.

```APIDOC
## GET /swap

### Description
Retrieves information about the system's swap space usage, including total, free, and used swap.

### Method
GET

### Endpoint
/swap

### Response
#### Success Response (200)
- **total** (string) - The total amount of swap space.
- **free** (string) - The amount of free swap space.
- **used** (string) - The amount of used swap space.
- **platform_swap** (object) - Platform-specific swap details.

#### Response Example
```json
{
  "total": "4GB",
  "free": "4GB",
  "used": "0GB",
  "platform_swap": {}
}
```
```

--------------------------------

### Get System Boot Time

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/freebsd/struct.PlatformImpl.html

Returns the timestamp when the system was last booted.

```rust
fn boot_time(&self) -> Result<OffsetDateTime>
```

--------------------------------

### Example Usage of DelayedMeasurement

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.DelayedMeasurement.html

Demonstrates how DelayedMeasurement is used in practice, specifically for CPU load measurement.

```APIDOC
## Example: CPU Load Measurement

### Description
This example shows how to use `DelayedMeasurement` to measure CPU load. It involves creating the measurement, waiting for a second, and then calling `.done()` to get the results.

### Code Snippet
```rust
match sys.cpu_load_aggregate() {
    Ok(cpu)=> {
        println!("\nMeasuring CPU load...");
        thread::sleep(Duration::from_secs(1));
        let cpu = cpu.done().unwrap();
        println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
            cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
    },
    Err(x) => println!("\nCPU load: error: {}", x)
}
```
```

--------------------------------

### GET /cpu-load

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Measures and retrieves the current CPU load.

```APIDOC
## GET /cpu-load

### Description
Measures and retrieves the current CPU load, broken down by user, system, idle, etc.

### Method
GET

### Endpoint
/cpu-load

### Response
#### Success Response (200)
- **user** (float) - Percentage of CPU time spent in user mode.
- **nice** (float) - Percentage of CPU time spent in nice mode.
- **system** (float) - Percentage of CPU time spent in system mode.
- **interrupt** (float) - Percentage of CPU time spent handling interrupts.
- **idle** (float) - Percentage of CPU time spent idle.

#### Response Example
```json
{
  "user": 10.5,
  "nice": 0.1,
  "system": 5.2,
  "interrupt": 1.0,
  "idle": 83.2
}
```
```

--------------------------------

### GET /cpu-temp

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves the current CPU temperature.

```APIDOC
## GET /cpu-temp

### Description
Retrieves the current temperature of the CPU.

### Method
GET

### Endpoint
/cpu-temp

### Response
#### Success Response (200)
- **temperature** (string) - The CPU temperature (e.g., "55.0°C").

#### Response Example
```json
{
  "temperature": "55.0°C"
}
```
```

--------------------------------

### GET /load-average

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves the system's load average.

```APIDOC
## GET /load-average

### Description
Retrieves the system's load average over the last 1, 5, and 15 minutes.

### Method
GET

### Endpoint
/load-average

### Response
#### Success Response (200)
- **one** (float) - Load average over the last minute.
- **five** (float) - Load average over the last 5 minutes.
- **fifteen** (float) - Load average over the last 15 minutes.

#### Response Example
```json
{
  "one": 0.5,
  "five": 0.75,
  "fifteen": 0.8
}
```
```

--------------------------------

### Get System Mounts and Statistics

Source: https://docs.rs/systemstat/0.2.6/src/info/info.rs.html

Retrieves and prints information about all mounted file systems and a specific mount at '/'. Requires the systemstat crate.

```Rust
extern crate systemstat;

use std::thread;
use std::time::Duration;
use systemstat::{System, Platform, saturating_sub_bytes};

fn main() {
    let sys = System::new();

    match sys.mounts() {
        Ok(mounts) => {
            println!("\nMounts:");
            for mount in mounts.iter() {
                println!("{} ---{}---> {} (available {} of {})",
                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
            }
        }
        Err(x) => println!("\nMounts: error: {}", x)
    }

    match sys.mount_at("/") {
        Ok(mount) => {
            println!("\nMount at /:");
            println!("{} ---{}---> {} (available {} of {})",
                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
        }
        Err(x) => println!("\nMount at /: error: {}", x)
    }

    match sys.block_device_statistics() {
        Ok(stats) => {
            for blkstats in stats.values() {
                println!("{}: {:?}", blkstats.name, blkstats);
            }
        }
        Err(x) => println!("\nBlock statistics error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetworks:");
            for netif in netifs.values() {
                println!("{} ({:?})", netif.name, netif.addrs);
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetwork interface statistics:");
            for netif in netifs.values() {
                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.battery_life() {
        Ok(battery) =>
            print!("\nBattery: {}%, {}h{}m remaining",
                   battery.remaining_capacity*100.0,
                   battery.remaining_time.as_secs() / 3600,
                   battery.remaining_time.as_secs() % 60),
        Err(x) => print!("\nBattery: error: {}", x)
    }

    match sys.on_ac_power() {
        Ok(power) => println!(', AC power: {}', power),
        Err(x) => println!(', AC power: error: {}', x)
    }

    match sys.memory() {
        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
        Err(x) => println!("\nMemory: error: {}", x)
    }

    match sys.swap() {
        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
        Err(x) => println!("\nSwap: error: {}", x)
    }

    match sys.load_average() {
        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
        Err(x) => println!("\nLoad average: error: {}", x)
    }

    match sys.uptime() {
        Ok(uptime) => println!("\nUptime: {:?}", uptime),
        Err(x) => println!("\nUptime: error: {}", x)
    }

    match sys.boot_time() {
        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
        Err(x) => println!("\nBoot time: error: {}", x)
    }

    match sys.cpu_load_aggregate() {
        Ok(cpu)=> {
            println!("\nMeasuring CPU load...");
            thread::sleep(Duration::from_secs(1));
            let cpu = cpu.done().unwrap();
            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
        },
        Err(x) => println!("\nCPU load: error: {}", x)
    }

    match sys.cpu_temp() {
        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
        Err(x) => println!("\nCPU temp: {}", x)
    }

    match sys.socket_stats() {
        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
        Err(x) => println!("\nSystem socket statistics: error: {}", x)
    }
}
```

--------------------------------

### GET /mounts/{path}

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Retrieves mount information for a specific path.

```APIDOC
## GET /mounts/{path}

### Description
Retrieves the filesystem mount information for a given path.

### Method
GET

### Endpoint
/mounts/{path}

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to check for mount information.

### Response
#### Success Response (200)
- **fs_mounted_from** (string) - The source of the mount.
- **fs_type** (string) - The type of the filesystem.
- **fs_mounted_on** (string) - The mount point path.
- **avail** (string) - The available space.
- **total** (string) - The total space.

#### Response Example
```json
{
  "fs_mounted_from": "/dev/sda1",
  "fs_type": "ext4",
  "fs_mounted_on": "/",
  "avail": "100GB",
  "total": "200GB"
}
```
```

--------------------------------

### Platform Trait Documentation

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/common/trait.Platform.html

Documentation for the Platform trait, which declares functions for getting system information. Any implementation must override either `uptime` or `boot_time`.

```APIDOC
## Trait Platform

### Description
The `Platform` trait declares all the functions for getting system information.

**Note:** Any implementation MUST override one of `uptime` or `boot_time`.

### Methods

#### `new()`

```rust
fn new() -> Self;
```

#### `cpu_load()`

```rust
fn cpu_load(&self) -> Result<DelayedMeasurement<Vec<CPULoad>>>;
```

Returns a delayed vector of CPU load statistics, one object per CPU (core). You need to wait some time (about a second is good) before unwrapping the `DelayedMeasurement` with `.done()`.

#### `load_average()`

```rust
fn load_average(&self) -> Result<LoadAverage>;
```

Returns a load average object.

#### `memory()`

```rust
fn memory(&self) -> Result<Memory>;
```

Returns a memory information object.

#### `swap()`

```rust
fn swap(&self) -> Result<Swap>;
```

Returns a swap memory information object.

#### `battery_life()`

```rust
fn battery_life(&self) -> Result<BatteryLife>;
```

Returns a battery life information object.

#### `on_ac_power()`

```rust
fn on_ac_power(&self) -> Result<bool>;
```

Returns whether AC power is plugged in.

#### `mounts()`

```rust
fn mounts(&self) -> Result<Vec<Filesystem>>;
```

Returns a vector of filesystem mount information objects.

#### `block_device_statistics()`

```rust
fn block_device_statistics(&self) -> Result<BTreeMap<String, BlockDeviceStats>>;
```

Returns a map of block device statistics objects.

#### `networks()`

```rust
fn networks(&self) -> Result<BTreeMap<String, Network>>;
```

Returns a map of network interface information objects. It’s a map because most operating systems return an object per IP address, not per interface, and we’re doing deduplication and packing everything into one object per interface. You can use the `.values()` iterator if you need to iterate over all of them.

#### `network_stats()`

```rust
fn network_stats(&self, interface: &str) -> Result<NetworkStats>;
```

Returns statistics for a given interface (bytes/packets sent/received).

#### `cpu_temp()`

```rust
fn cpu_temp(&self) -> Result<f32>;
```

Returns the current CPU temperature in degrees Celsius. Depending on the platform, this might be core 0, package, etc.

#### `socket_stats()`

```rust
fn socket_stats(&self) -> Result<SocketStats>;
```

Returns information about the number of sockets in use.

#### `cpu_load_aggregate()`

```rust
fn cpu_load_aggregate(&self) -> Result<DelayedMeasurement<CPULoad>>;
```

Returns a delayed CPU load statistics object, average over all CPUs (cores). You need to wait some time (about a second is good) before unwrapping the `DelayedMeasurement` with `.done()`.

#### `memory_and_swap()`

```rust
fn memory_and_swap(&self) -> Result<(Memory, Swap)>;
```

#### `uptime()`

```rust
fn uptime(&self) -> Result<Duration>;
```

#### `boot_time()`

```rust
fn boot_time(&self) -> Result<OffsetDateTime>;
```

#### `mount_at()`

```rust
fn mount_at<P: AsRef<Path>>(&self, path: P) -> Result<Filesystem>;
```
```

--------------------------------

### Get Filesystem Mount Information

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/freebsd/struct.PlatformImpl.html

Returns a vector of Filesystem objects, each representing a mounted filesystem with details like type, mount point, and size.

```rust
fn mounts(&self) -> Result<Vec<Filesystem>>
```

--------------------------------

### Documenting a Public Function in Rust

Source: https://docs.rs/systemstat/0.2.6/scrape-examples-help.html

This shows a basic public function definition in Rust that can be documented and have examples scraped.

```rust
// src/lib.rs
pub fn a_func() {}
```

--------------------------------

### Entry API

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Provides complex methods for getting, setting, updating, and removing keys and their values.

```APIDOC
## POST /BTreeMap/entry

### Description
Allows for complex manipulation of map entries, such as conditional insertion or modification.

### Method
POST

### Endpoint
BTreeMap::entry(key)

### Parameters
#### Request Body
- **key** (K) - Required - The key to access or modify.

### Response
#### Success Response (200)
- **entry** (Entry) - An entry handle for performing operations like or_insert, or_insert_with, or and_modify.
```

--------------------------------

### Get Monday-Based Week Number

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.OffsetDateTime.html

Calculate the week number where week 1 starts on a Monday. The result is in the range 0-53.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);
```

--------------------------------

### Query System Statistics

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/fn.saturating_sub_bytes.html

Demonstrates how to initialize the System struct and retrieve various hardware and OS metrics including mounts, network interfaces, memory, and CPU load.

```rust
fn main() {
    let sys = System::new();

    match sys.mounts() {
        Ok(mounts) => {
            println!("\nMounts:");
            for mount in mounts.iter() {
                println!("{} ---{}---> {} (available {} of {})",
                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
            }
        }
        Err(x) => println!("\nMounts: error: {}", x)
    }

    match sys.mount_at("/") {
        Ok(mount) => {
            println!("\nMount at /:");
            println!("{} ---{}---> {} (available {} of {})",
                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
        }
        Err(x) => println!("\nMount at /: error: {}", x)
    }

    match sys.block_device_statistics() {
        Ok(stats) => {
            for blkstats in stats.values() {
                println!("{}: {:?}", blkstats.name, blkstats);
            }
        }
        Err(x) => println!("\nBlock statistics error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetworks:");
            for netif in netifs.values() {
                println!("{} ({:?})", netif.name, netif.addrs);
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            println!("\nNetwork interface statistics:");
            for netif in netifs.values() {
                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
            }
        }
        Err(x) => println!("\nNetworks: error: {}", x)
    }

    match sys.battery_life() {
        Ok(battery) =>
            print!("\nBattery: {}%, {}h{}m remaining",
                   battery.remaining_capacity*100.0,
                   battery.remaining_time.as_secs() / 3600,
                   battery.remaining_time.as_secs() % 60),
        Err(x) => print!("\nBattery: error: {}", x)
    }

    match sys.on_ac_power() {
        Ok(power) => println!(", AC power: {}", power),
        Err(x) => println!(", AC power: error: {}", x)
    }

    match sys.memory() {
        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
        Err(x) => println!("\nMemory: error: {}", x)
    }

    match sys.swap() {
        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
        Err(x) => println!("\nSwap: error: {}", x)
    }

    match sys.load_average() {
        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
        Err(x) => println!("\nLoad average: error: {}", x)
    }

    match sys.uptime() {
        Ok(uptime) => println!("\nUptime: {:?}", uptime),
        Err(x) => println!("\nUptime: error: {}", x)
    }

    match sys.boot_time() {
        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
        Err(x) => println!("\nBoot time: error: {}", x)
    }

    match sys.cpu_load_aggregate() {
        Ok(cpu)=> {
            println!("\nMeasuring CPU load...");
            thread::sleep(Duration::from_secs(1));
            let cpu = cpu.done().unwrap();
            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
        },
        Err(x) => println!("\nCPU load: error: {}", x)
    }

    match sys.cpu_temp() {
        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
        Err(x) => println!("\nCPU temp: {}", x)
    }

    match sys.socket_stats() {
        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
        Err(x) => println!("\nSystem socket statistics: error: {}", x)
    }
}
```

--------------------------------

### Get Sunday-Based Week Number

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.OffsetDateTime.html

Calculate the week number where week 1 starts on a Sunday. The result is in the range 0-53.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);
```

--------------------------------

### Get Total Nanoseconds from Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Illustrates how to get the total number of nanoseconds contained within a Duration.

```rust
use std::time::Duration;

let duration = Duration::new(5, 730_023_852);
assert_eq!(duration.as_nanos(), 5_730_023_852);
```

--------------------------------

### Initialize systemstat library

Source: https://docs.rs/systemstat/0.2.6/src/systemstat/lib.rs.html

The main library entry point defining modules and platform-specific imports.

```rust
1//! This library provides a way to access system information such as CPU load, mounted filesystems,
2//! network interfaces, etc.
3
4#[cfg_attr(
5    any(
6        target_os = "freebsd",
7        target_os = "openbsd",
8        target_os = "netbsd",
9        target_vendor = "apple"
10    ),
11    macro_use
12)]
13extern crate lazy_static;
14
15#[cfg(feature = "serde")]
16extern crate the_serde as serde;
17
18pub mod data;
19pub mod platform;
20mod reader_utils;
21
22pub use self::data::*;
23pub use self::platform::Platform;
24pub use self::platform::PlatformImpl as System;
```

--------------------------------

### Get Ipv4Addr Size in Bits

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Ipv4Addr.html

Shows how to get the size of an IPv4 address in bits, which is a constant value.

```rust
use std::net::Ipv4Addr;

assert_eq!(Ipv4Addr::BITS, 32);
```

--------------------------------

### Get Total Microseconds from Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Shows how to get the total number of whole microseconds contained within a Duration.

```rust
use std::time::Duration;

let duration = Duration::new(5, 730_023_852);
assert_eq!(duration.as_micros(), 5_730_023);
```

--------------------------------

### PlatformCpuLoad Methods (Linux)

Source: https://docs.rs/systemstat/0.2.6/src/systemstat/data.rs.html

Provides methods for averaging, initializing to zero, creating from a value, and summing CPU load metrics on Linux.

```rust
impl PlatformCpuLoad {
    #[inline(always)]
    pub fn avg_add(self, rhs: &Self) -> Self {
        PlatformCpuLoad {
            iowait: (self.iowait + rhs.iowait) / 2.0,
        }
    }

    #[inline(always)]
    pub fn zero() -> Self {
        PlatformCpuLoad { iowait: 0.0 }
    }

    #[inline(always)]
    pub fn from(input: f32) -> Self {
        PlatformCpuLoad { iowait: input }
    }

    #[inline(always)]
    pub fn sum(&self) -> f32 {
        self.iowait
    }
}
```

--------------------------------

### Get Total Milliseconds from Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Demonstrates how to get the total number of whole milliseconds contained within a Duration.

```rust
use std::time::Duration;

let duration = Duration::new(5, 730_023_852);
assert_eq!(duration.as_millis(), 5_730);
```

--------------------------------

### Retrieve System Metrics

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.ByteSize.html

Demonstrates how to use the System struct to query various hardware and OS metrics including mounts, network interfaces, CPU load, and memory usage.

```rust
7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}
```

--------------------------------

### Get Whole Seconds from Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Illustrates how to get the number of whole seconds from a Duration, excluding the fractional part.

```rust
use std::time::Duration;

let duration = Duration::new(5, 730_023_852);
assert_eq!(duration.as_secs(), 5);
```

--------------------------------

### Get Values Iterator - BTreeMap

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Gets an iterator over the values of the map, in order by key. This method borrows the map immutably.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);
```

--------------------------------

### Get Keys Iterator - BTreeMap

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Gets an iterator over the keys of the map, in sorted order. This method borrows the map immutably.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);
```

--------------------------------

### Initialize and Use BTreeMap

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Demonstrates basic BTreeMap operations including insertion, checking for keys, removing entries, retrieving values, and iterating over the map. Use this for general-purpose ordered key-value storage.

```rust
use std::collections::BTreeMap;

// type inference lets us omit an explicit type signature (which
// would be `BTreeMap<&str, &str>` in this example).
let mut movie_reviews = BTreeMap::new();

// review some movies.
movie_reviews.insert("Office Space",       "Deals with real issues in the workplace.");
movie_reviews.insert("Pulp Fiction",       "Masterpiece.");
movie_reviews.insert("The Godfather",      "Very enjoyable.");
movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot.");

// check for a specific one.
if !movie_reviews.contains_key("Les Misérables") {
    println!("We've got {} reviews, but Les Misérables ain't one.",
             movie_reviews.len());
}

// oops, this review has a lot of spelling mistakes, let's delete it.
movie_reviews.remove("The Blues Brothers");

// look up the values associated with some keys.
let to_find = ["Up!", "Office Space"];
for movie in &to_find {
    match movie_reviews.get(movie) {
       Some(review) => println!("{movie}: {review}"),
       None => println!("{movie} is unreviewed.")
    }
}

// Look up the value for a key (will panic if the key is not found).
println!("Movie review: {}", movie_reviews["Office Space"]);

// iterate over everything.
for (movie, review) in &movie_reviews {
    println!("{movie}: \"{review}\" ");
}
```

--------------------------------

### Get Fractional Microseconds from Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Shows how to get the fractional part of a Duration in whole microseconds. This value is less than one million.

```rust
use std::time::Duration;

let duration = Duration::from_micros(1_234_567);
assert_eq!(duration.as_secs(), 1);
assert_eq!(duration.subsec_micros(), 234_567);
```

--------------------------------

### PlatformCpuLoad Methods (Non-Linux)

Source: https://docs.rs/systemstat/0.2.6/src/systemstat/data.rs.html

Provides stub implementations for averaging, initializing to zero, creating from a value, and summing CPU load metrics on non-Linux platforms.

```rust
impl PlatformCpuLoad {
    #[inline(always)]
    pub fn avg_add(self, _rhs: &Self) -> Self {
        PlatformCpuLoad {}
    }

    #[inline(always)]
    pub fn zero() -> Self {
        PlatformCpuLoad {}
    }

    #[inline(always)]
    pub fn from(_input: f32) -> Self {
        PlatformCpuLoad {}
    }

    #[inline(always)]
    pub fn sum(&self) -> f32 {
        0.0
    }
}
```

--------------------------------

### Initialize BTreeMap with custom allocator

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Creates an empty BTreeMap using a specific allocator. Requires the nightly-only experimental API.

```rust
use std::collections::BTreeMap;
use std::alloc::Global;

let mut map = BTreeMap::new_in(Global);

// entries can now be inserted into the empty map
map.insert(1, "a");
```

--------------------------------

### Get Block Device Statistics

Source: https://docs.rs/systemstat/0.2.6/systemstat/platform/freebsd/struct.PlatformImpl.html

Returns a map where keys are block device names and values are BlockDeviceStats objects, providing I/O statistics for each device.

```rust
fn block_device_statistics(&self) -> Result<BTreeMap<String, BlockDeviceStats>>
```

--------------------------------

### Get Ordinal Day

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.OffsetDateTime.html

Get the day of the year (1-366) from a `DateTime` in its stored offset. This represents the day's position within the year.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).ordinal(), 1);
assert_eq!(
    datetime!(2019-12-31 23:00 UTC)
        .to_offset(offset!(+1))
        .ordinal(),
    1,
);
```

--------------------------------

### Create and check Ipv6Addr localhost

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Ipv6Addr.html

Demonstrates creating the IPv6 loopback address and checking if an address is a loopback address. Requires importing `std::net::Ipv6Addr`.

```rust
use std::net::Ipv6Addr;

let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
assert_eq!("::1".parse(), Ok(localhost));
assert_eq!(localhost.is_loopback(), true);
```

--------------------------------

### Create and Manipulate Duration

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.Duration.html

Demonstrates creating Duration instances using `new` and `from_millis`, and performing addition. It also shows how to extract seconds and nanoseconds using `as_secs` and `subsec_nanos`.

```rust
use std::time::Duration;

let five_seconds = Duration::new(5, 0);
let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);

assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);
assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);

let ten_millis = Duration::from_millis(10);
```

--------------------------------

### Get Mutable Values Iterator - BTreeMap

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Gets a mutable iterator over the values of the map, in order by key. This method requires a mutable borrow of the map.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, String::from("hello"));
a.insert(2, String::from("goodbye"));

for value in a.values_mut() {
    value.push_str("!");
}

let values: Vec<String> = a.values().cloned().collect();
assert_eq!(values, [String::from("hello!"),
                    String::from("goodbye!")]);
```

--------------------------------

### Iterate over a BTreeMap sub-range

Source: https://docs.rs/systemstat/0.2.6/systemstat/data/struct.BTreeMap.html

Use `range` with `Bound` or range syntax to iterate over a specific sub-range of elements. Panics if range start > end or if start == end with both bounds excluded.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!(ירת{key}: {value});
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());
```
Tokens:
Raw