chore: Bump Rust dependencies and Rust version (#52)

* chore: Bump Rust dependencies and Rust version

* bump Rust

* Bump cargo-deny

* Use op-rs 0.107.0

* changelog

Author: sbernauer

crates/containerdebug/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Changed
+
+- Dependency bumps. This includes switching to async code (using `tokio`), as `hickory-resolver` 0.25 removed the synchronous APIs ([#52]).
+
+[#52]: https://github.com/stackabletech/containerdebug/pull/52
+
 ## [0.2.0] - 2025-05-26
 
 ### Changed

crates/containerdebug/Cargo.toml

@@ -5,15 +5,17 @@ edition = "2024"
 
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
-
-hickory-resolver = "0.24"
+hickory-resolver = "0.25"
 local-ip-address = "0.6"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-snafu = "0.8"
-stackable-operator = { git = "https://github.com/stackabletech/operator-rs", tag = "stackable-operator-0.93.1", features = ["telemetry"] }
-sysinfo = { version = "0.35", features = ["serde"] }
+snafu = "0.9"
+sysinfo = { version = "0.38", features = ["serde"] }
+tokio = { version = "1.49", default-features = false, features = ["rt-multi-thread", "macros"] }
 tracing = "0.1"
 
+stackable-shared = {git = "https://github.com/stackabletech/operator-rs", tag = "stackable-operator-0.107.0", default-features = false }
+stackable-telemetry = {git = "https://github.com/stackabletech/operator-rs", tag = "stackable-operator-0.107.0", default-features = false, features = ["clap"] }
+
 [build-dependencies]
 built = { version = "0.8", features = ["chrono", "git2"] }

crates/containerdebug/src/main.rs

@@ -2,11 +2,10 @@ mod error;
 mod system_information;
 
 use clap::Parser;
-use stackable_operator::telemetry::Tracing;
+use stackable_telemetry::{Tracing, tracing::TelemetryOptions};
 use std::path::PathBuf;
 
 use crate::system_information::SystemInformation;
-use stackable_operator::telemetry::tracing::TelemetryOptions;
 use std::time::Instant;
 
 const APP_NAME: &str = "containerdebug";
@@ -22,7 +21,7 @@ struct Opts {
         num_args = 0..=1,
         require_equals = true,
     )]
-    loop_interval: Option<stackable_operator::time::Duration>,
+    loop_interval: Option<stackable_shared::time::Duration>,
 
     /// Write collected information to OUTPUT as JSON
     #[clap(long, short = 'o')]
@@ -36,7 +35,8 @@ mod built_info {
     include!(concat!(env!("OUT_DIR"), "/built.rs"));
 }
 
-fn main() {
+#[tokio::main]
+async fn main() {
     let opts = Opts::parse();
 
     let _trace_guard = Tracing::pre_configured(APP_NAME, opts.telemetry_arguments)
@@ -70,7 +70,7 @@ fn main() {
         }
         std::thread::sleep(next_run_sleep);
 
-        let system_information = SystemInformation::collect(&mut collect_ctx);
+        let system_information = SystemInformation::collect(&mut collect_ctx).await;
 
         let serialized = serde_json::to_string_pretty(&system_information).unwrap();
         if let Some(output_path) = &opts.output {

crates/containerdebug/src/system_information/mod.rs

@@ -59,7 +59,7 @@ impl SystemInformation {
 
     /// Collects and reports
     #[tracing::instrument(name = "SystemInformation::collect", skip(ctx))]
-    pub fn collect(ctx: &mut CollectContext) -> Self {
+    pub async fn collect(ctx: &mut CollectContext) -> Self {
         tracing::debug!("Starting data collection");
 
         let info = Self {
@@ -70,7 +70,7 @@ impl SystemInformation {
                 user::User::collect_current(&ctx.system),
             )),
             disks: Some(disk::Disk::collect_all()),
-            network: Some(network::SystemNetworkInfo::collect()),
+            network: Some(network::SystemNetworkInfo::collect().await),
             // ..Default::default()
         };
 

crates/containerdebug/src/system_information/network.rs

@@ -1,11 +1,25 @@
-use hickory_resolver::{Resolver, system_conf::read_system_conf};
+use hickory_resolver::{
+    TokioResolver, name_server::TokioConnectionProvider, system_conf::read_system_conf,
+};
 use local_ip_address::list_afinet_netifas;
 use serde::Serialize;
 use std::{
     collections::{BTreeSet, HashMap},
     net::IpAddr,
+    sync::LazyLock,
     time::Duration,
 };
+use tokio::task::JoinSet;
+
+static GLOBAL_DNS_RESOLVER: LazyLock<TokioResolver> = LazyLock::new(|| {
+    let (resolver_config, mut resolver_opts) =
+        read_system_conf().expect("failed to read system resolv config");
+    resolver_opts.timeout = Duration::from_secs(5);
+
+    TokioResolver::builder_with_config(resolver_config, TokioConnectionProvider::default())
+        .with_options(resolver_opts)
+        .build()
+});
 
 /// Captures all system network information, including network interfaces,
 /// and the results of reverse and forward DNS lookups.
@@ -18,16 +32,7 @@ pub struct SystemNetworkInfo {
 
 impl SystemNetworkInfo {
     #[tracing::instrument(name = "SystemNetworkInfo::collect")]
-    pub fn collect() -> SystemNetworkInfo {
-        /*
-        let resolver = Resolver::from_system_conf()
-            .map_err(|e| e.to_string())
-            .unwrap();
-         */
-        let (resolver_config, mut resolver_opts) = read_system_conf().unwrap();
-        resolver_opts.timeout = Duration::from_secs(5);
-        let resolver = Resolver::new(resolver_config, resolver_opts).unwrap();
-
+    pub async fn collect() -> SystemNetworkInfo {
         let interfaces = match list_afinet_netifas() {
             Ok(netifs) => {
                 let mut interface_map = std::collections::HashMap::new();
@@ -56,12 +61,19 @@ impl SystemNetworkInfo {
             }
         };
 
-        let ip_set: BTreeSet<IpAddr> = interfaces.values().flatten().copied().collect();
-        tracing::info!(network.addresses.ip = ?ip_set, "ip addresses");
+        let ips: BTreeSet<IpAddr> = interfaces.values().flatten().copied().collect();
+        tracing::info!(network.addresses.ip = ?ips, "ip addresses");
 
-        let reverse_lookups: HashMap<IpAddr, Vec<String>> = ip_set
+        let mut reverse_lookups = JoinSet::new();
+        for ip in ips {
+            reverse_lookups
+                .spawn(async move { (ip, GLOBAL_DNS_RESOLVER.reverse_lookup(ip).await) });
+        }
+        let reverse_lookups: HashMap<IpAddr, Vec<String>> = reverse_lookups
+            .join_all()
+            .await
             .into_iter()
-            .filter_map(|ip| match resolver.reverse_lookup(ip) {
+            .filter_map(|(ip, reverse_lookup)| match reverse_lookup {
                 Ok(result) => {
                     let hostnames = result
                         .into_iter()
@@ -84,9 +96,20 @@ impl SystemNetworkInfo {
         let hostname_set: BTreeSet<String> = reverse_lookups.values().flatten().cloned().collect();
         tracing::info!(network.addresses.hostname = ?hostname_set, "hostnames");
 
-        let forward_lookups: HashMap<String, Vec<IpAddr>> = hostname_set
+        let mut forward_lookups = JoinSet::new();
+        for hostname in hostname_set {
+            forward_lookups.spawn(async move {
+                (
+                    hostname.clone(),
+                    GLOBAL_DNS_RESOLVER.lookup_ip(hostname).await,
+                )
+            });
+        }
+        let forward_lookups: HashMap<String, Vec<IpAddr>> = forward_lookups
+            .join_all()
+            .await
             .into_iter()
-            .filter_map(|hostname| match resolver.lookup_ip(hostname.clone()) {
+            .filter_map(|(hostname, forward_lookup)| match forward_lookup {
                 Ok(result) => {
                     let ips = result.iter().collect();
                     tracing::info!(hostname, ?ips, "performed forward DNS lookup for hostname");