darwin-metrics 0.1.5

A Rust library exposing native macOS system metrics
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

use std::time::Duration;

use darwin_metrics::network::{NetworkManager, NetworkMetrics};

#[tokio::main]
async fn main() -> darwin_metrics::Result<()> {
    // Create a new network manager asynchronously
    let mut network = NetworkManager::new_async().await?;

    println!("Initial network statistics:");
    for interface in network.interfaces() {
        if interface.is_active() {
            println!("{} ({})", interface.name(), interface.interface_type());
            println!("  Bytes received: {}", interface.bytes_received());
            println!("  Bytes sent: {}", interface.bytes_sent());
        }
    }

    // Sleep asynchronously to allow traffic to occur
    println!("\nWaiting 3 seconds for network activity...");
    tokio::time::sleep(Duration::from_secs(3)).await;

    // Update statistics asynchronously
    network.update_async().await?;

    // Get active interfaces only
    println!("\nActive interfaces:");
    let active_interfaces = network.active_interfaces_async().await;
    for interface in active_interfaces {
        println!("{} ({})", interface.name(), interface.interface_type());
    }

    // Get total network usage
    let (download, upload) = network.get_throughput_async().await?;
    println!("\nTotal network usage:");
    println!("  Download: {:.2} KB/s", download / 1024.0);
    println!("  Upload: {:.2} KB/s", upload / 1024.0);

    // Check for a specific interface asynchronously
    if let Some(en0) = network.get_interface_async("en0").await {
        println!("\nNetwork stats for en0:");
        println!("  Download: {:.2} KB/s", en0.download_speed() / 1024.0);
        println!("  Upload: {:.2} KB/s", en0.upload_speed() / 1024.0);
    }

    Ok(())
}