chore: enable more strict clippy warnings

Leandros · Leandros · commit 6ec663bfdf81 · 2025-06-25T05:58:23.000Z
diff --git a/Cargo.toml b/Cargo.toml
diff --git a/clippy.toml b/clippy.toml
@@ -0,0 +1 @@
+allow-unwrap-in-tests = true
diff --git a/src/args.rs b/src/args.rs
@@ -6,7 +6,7 @@ use std::process::exit;
 use anyhow::Result;
 
 /// Args passed into the application.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct CliArgs {
     /// Optional listen address. By default, listens on `127.0.0.1`
     pub listen_address: String,
diff --git a/src/collector.rs b/src/collector.rs
@@ -12,7 +12,8 @@ use smol::lock::RwLock;
 
 use crate::config::UserConfig;
 use crate::metrics::collector::{
-    CpuStatsCollector, DiskStatsCollector, FilesystemStatsCollector, MemoryStatsCollector, NetworkStatsCollector, NodeInfoCollector, PressureCollector, SystemdUnitStateCollector
+    CpuStatsCollector, DiskStatsCollector, FilesystemStatsCollector, MemoryStatsCollector,
+    NetworkStatsCollector, NodeInfoCollector, PressureCollector, SystemdUnitStateCollector,
 };
 use crate::metrics::Metric;
 
@@ -50,7 +51,7 @@ impl Collector {
 
         let metrics = &config.metrics;
         {
-            let collector = Box::new(NodeInfoCollector::new().await?);
+            let collector = Box::new(NodeInfoCollector::new()?);
             inner.metrics.push(collector);
         }
 
@@ -75,21 +76,21 @@ impl Collector {
         if metrics.systemd_unit_state.enabled {
             let units = metrics.systemd_unit_state.units.join(",");
             let options = HashMap::from([("units".to_owned(), units)]);
-            let collector = Box::new(SystemdUnitStateCollector::new(options).await?);
+            let collector = Box::new(SystemdUnitStateCollector::new(&options).await?);
             inner.metrics.push(collector);
         }
 
         if metrics.network_throughput.enabled {
             let interfaces = metrics.network_throughput.interfaces.join(",");
             let options = HashMap::from([("interfaces".to_owned(), interfaces)]);
-            let collector = Box::new(NetworkStatsCollector::new(options).await?);
+            let collector = Box::new(NetworkStatsCollector::new(&options)?);
             inner.metrics.push(collector);
         }
 
         if metrics.disk_usage.enabled {
             let mountpoints = metrics.disk_usage.mountpoints.join(",");
             let options = HashMap::from([("mountpoints".to_owned(), mountpoints)]);
-            let collector = Box::new(FilesystemStatsCollector::new(options).await?);
+            let collector = Box::new(FilesystemStatsCollector::new(&options)?);
             inner.metrics.push(collector);
         }
 
@@ -101,7 +102,7 @@ impl Collector {
         if metrics.disk_stats.enabled {
             let mountpoints = metrics.disk_stats.mountpoints.join(",");
             let options = HashMap::from([("mountpoints".to_owned(), mountpoints)]);
-            let collector = Box::new(DiskStatsCollector::new(options)?);
+            let collector = Box::new(DiskStatsCollector::new(&options)?);
             inner.metrics.push(collector);
         }
 
@@ -129,7 +130,7 @@ impl Collector {
             .collect();
         let results = futs.join().await;
         for res in results {
-            res.inspect_err(|err| eprintln!("{err:?}"))
+            res.inspect_err(|err| eprintln!("{err}"))
                 .context("collecting metrics")?;
         }
 
diff --git a/src/config.rs b/src/config.rs
@@ -106,6 +106,7 @@ impl Default for MetricsConfig {
 
 impl UserConfig {
     /// Load the configuratin from the `path` specified.
+    #[allow(clippy::too_many_lines, clippy::shadow_unrelated)]
     pub async fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
         let docstr = smol::fs::read_to_string(path.as_ref())
             .await
diff --git a/src/http.rs b/src/http.rs
@@ -37,11 +37,11 @@ async fn serve_request(
 
     match (req.method(), req.uri().path()) {
         (&Method::GET, "/metrics") => {
-            let res = serve_metrics(&collector)
+            let response = serve_metrics(&collector)
                 .await
                 .inspect_err(|err| eprintln!("error serving metrics request: {err}"))
                 .unwrap_or_else(|_err| internal_server_error());
-            Ok(res)
+            Ok(response)
         }
 
         (_, _) => Ok(not_found()),
diff --git a/src/main.rs b/src/main.rs
@@ -1,3 +1,4 @@
+//! LiteMon. Lightweight prometheus metrics for Linux.
 use std::rc::Rc;
 
 use litemon::args::CliArgs;
@@ -7,6 +8,7 @@ use litemon::http;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
+/// Global Jemalloc allocator.
 #[global_allocator]
 static GLOBAL_ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
@@ -27,6 +29,7 @@ fn main() {
 }
 
 /// Real, asynchronous entrypoint.
+#[allow(clippy::future_not_send)]
 async fn async_main(_ex: &Rc<smol::LocalExecutor<'_>>) {
     let args = CliArgs::from_env().expect("invalid args");
     let config = UserConfig::from_path(&args.config_path)
@@ -54,5 +57,5 @@ async fn async_main(_ex: &Rc<smol::LocalExecutor<'_>>) {
 
     http::listen(collector.clone(), &args.listen_address, args.listen_port)
         .await
-        .unwrap();
+        .expect("starting http server");
 }
diff --git a/src/metrics/collector.rs b/src/metrics/collector.rs
@@ -125,9 +125,9 @@ impl Metric for CpuStatsCollector {
                 .load_avg_enabled
                 .load(std::sync::atomic::Ordering::Acquire)
             {
-                self.load_avg_1m.set(load_avg.one as f64);
-                self.load_avg_5m.set(load_avg.five as f64);
-                self.load_avg_15m.set(load_avg.fifteen as f64);
+                self.load_avg_1m.set(f64::from(load_avg.one));
+                self.load_avg_5m.set(f64::from(load_avg.five));
+                self.load_avg_15m.set(f64::from(load_avg.fifteen));
             }
 
             let current_snapshot = CpuUsage::now().await?;
@@ -165,15 +165,16 @@ struct FilesystemLabels {
 }
 
 impl FilesystemStatsCollector {
-    pub async fn new(options: hashbrown::HashMap<String, String>) -> Result<Self> {
-        let mountpoints = if let Some(mountpoints_str) = options.get("mountpoints") {
-            mountpoints_str
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .collect()
-        } else {
-            vec!["/".to_string()] // Default to root filesystem
-        };
+    pub fn new(options: &hashbrown::HashMap<String, String>) -> Result<Self> {
+        let mountpoints = options.get("mountpoints").map_or_else(
+            || vec!["/".to_string()],
+            |mountpoints_str| {
+                mountpoints_str
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect()
+            },
+        );
 
         Ok(Self {
             fs_usage_ratio: Default::default(),
@@ -238,16 +239,16 @@ struct NetworkLabels {
 }
 
 impl NetworkStatsCollector {
-    pub async fn new(options: hashbrown::HashMap<String, String>) -> Result<Self> {
-        let interfaces = if let Some(interfaces_str) = options.get("interfaces") {
-            interfaces_str
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .collect()
-        } else {
-            // Default to common interfaces if none specified
-            vec!["eth0".to_string()]
-        };
+    pub fn new(options: &hashbrown::HashMap<String, String>) -> Result<Self> {
+        let interfaces = options.get("interfaces").map_or_else(
+            || vec!["eth0".to_string()],
+            |interfaces_str| {
+                interfaces_str
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect()
+            },
+        );
 
         Ok(Self {
             bytes_received: Default::default(),
@@ -283,6 +284,7 @@ impl Metric for NetworkStatsCollector {
         );
     }
 
+    #[allow(clippy::cast_precision_loss)]
     fn collect(&self) -> DynFuture<'_, Result<()>> {
         Box::pin(async move {
             let interfaces = &self.interfaces;
@@ -336,13 +338,11 @@ struct SystemdUnitLabels {
 }
 
 impl SystemdUnitStateCollector {
-    pub async fn new(options: hashbrown::HashMap<String, String>) -> Result<Self> {
+    pub async fn new(options: &hashbrown::HashMap<String, String>) -> Result<Self> {
         // Parse units from options
-        let units = if let Some(units_str) = options.get("units") {
+        let units = options.get("units").map_or_else(Vec::new, |units_str| {
             units_str.split(',').map(|s| s.trim().to_string()).collect()
-        } else {
-            Vec::new()
-        };
+        });
 
         let client = SystemdUnitState::new().await?;
 
@@ -374,7 +374,7 @@ impl Metric for SystemdUnitStateCollector {
                         for state_name in ActiveState::all_states() {
                             let labels = SystemdUnitLabels {
                                 unit: unit_name.clone(),
-                                state: state_name.to_string(),
+                                state: (*state_name).to_string(),
                             };
                             self.unit_state.get_or_create(&labels).set(0);
                         }
@@ -416,7 +416,7 @@ struct NodeInfoLabels {
 }
 
 impl NodeInfoCollector {
-    pub async fn new() -> Result<Self> {
+    pub fn new() -> Result<Self> {
         let info = NodeInfo::new()?;
 
         let labels = NodeInfoLabels {
@@ -437,7 +437,7 @@ impl Metric for NodeInfoCollector {
             "litemon_node_info",
             "System information about the node",
             self.metric.clone(),
-        )
+        );
     }
 
     fn collect(&self) -> DynFuture<'_, Result<()>> {
@@ -511,15 +511,16 @@ struct DiskStatsLabels {
 }
 
 impl DiskStatsCollector {
-    pub fn new(options: hashbrown::HashMap<String, String>) -> Result<Self> {
-        let mountpoints = if let Some(mountpoints_str) = options.get("mountpoints") {
-            mountpoints_str
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .collect()
-        } else {
-            vec!["/".to_string()] // Default to root filesystem
-        };
+    pub fn new(options: &hashbrown::HashMap<String, String>) -> Result<Self> {
+        let mountpoints = options.get("mountpoints").map_or_else(
+            || vec!["/".to_string()],
+            |mountpoints_str| {
+                mountpoints_str
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect()
+            },
+        );
 
         Ok(Self {
             bytes_written: Default::default(),
@@ -545,8 +546,8 @@ impl Metric for DiskStatsCollector {
 
     fn collect(&self) -> DynFuture<'_, Result<()>> {
         Box::pin(async move {
-            let stats = IOMetrics::all().await?;
-            for (device, stats) in &stats.disks {
+            let io = IOMetrics::all().await?;
+            for (device, stats) in &io.disks {
                 if !self.mountpoints.iter().any(|el| el == &stats.mountpoint) {
                     continue;
                 }
diff --git a/src/metrics/cpu.rs b/src/metrics/cpu.rs
@@ -52,21 +52,21 @@ pub struct CpuTime {
 }
 
 impl Add for CpuTime {
-    type Output = CpuTime;
+    type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
-        CpuTime {
+        Self {
             idle_ticks: self.idle_ticks + rhs.idle_ticks,
             total_ticks: self.total_ticks + rhs.total_ticks,
         }
     }
 }
 
 impl Sub for CpuTime {
-    type Output = CpuTime;
+    type Output = Self;
 
     fn sub(self, rhs: Self) -> Self::Output {
-        CpuTime {
+        Self {
             idle_ticks: self.idle_ticks - rhs.idle_ticks,
             total_ticks: self.total_ticks - rhs.total_ticks,
         }
@@ -75,7 +75,7 @@ impl Sub for CpuTime {
 
 impl CpuUsage {
     /// Retrieve the current CPU usage in ticks from boot.
-    pub async fn now() -> Result<CpuUsage> {
+    pub async fn now() -> Result<Self> {
         let stat = smol::unblock(|| {
             let ret = procfs::KernelStats::current().context("reading /proc/stat")?;
             Ok::<procfs::KernelStats, anyhow::Error>(ret)
@@ -115,13 +115,15 @@ impl CpuUsage {
     }
 
     /// Calculate the CPU usage between two snapshots taken via [`Self::now()`] for all CPU cores.
+    #[allow(clippy::cast_precision_loss)]
     pub fn percentage_all_cores(&self, prev: &Self) -> f64 {
         let diff = self.total_ticks - prev.total_ticks;
         (diff.total_ticks - diff.idle_ticks) as f64 / diff.total_ticks as f64
     }
 
     /// Calculate the CPU usage between two snapshots taken via [`Self::now()`] for each CPU core
     /// separately.
+    #[allow(clippy::cast_precision_loss)]
     pub fn percentage_per_core(&self, prev: &Self) -> Vec<f64> {
         self.per_core_ticks
             .iter()
diff --git a/src/metrics/disk.rs b/src/metrics/disk.rs
@@ -29,7 +29,7 @@ impl IOMetrics {
         // We try to only collect statistics about disks which are mounted.
         let mounts = smol::unblock(|| procfs::mounts().context("reading /proc/mounts")).await?;
 
-        let mut ret = IOMetrics {
+        let mut ret = Self {
             disks: HashMap::new(),
         };
 
diff --git a/src/metrics/fs.rs b/src/metrics/fs.rs
@@ -52,6 +52,7 @@ impl FilesystemUsage {
     ///     Ok(())
     /// }
     /// ```
+    #[allow(clippy::cast_precision_loss)]
     pub async fn new<P: AsRef<Path>>(mount_point: P) -> Result<Self> {
         // Convert the mount point to a string for storage
         let mount_point_str = mount_point
@@ -92,15 +93,15 @@ impl FilesystemUsage {
         let usage_ratio = if total_bytes > 0 {
             used_bytes as f64 / total_bytes as f64
         } else {
-            0.0
+            0.0_f64
         };
 
         // Get filesystem type and device information using procfs
         let (fs_type, device) = Self::get_fs_info(&mount_point_str)
             .await
             .context("get info for mountpoint")?;
 
-        Ok(FilesystemUsage {
+        Ok(Self {
             mount_point: mount_point_str,
             total_bytes,
             used_bytes,
@@ -121,7 +122,7 @@ impl FilesystemUsage {
         let mounts = smol::unblock(|| procfs::mounts().context("reading /proc/mounts")).await?;
 
         // Find the exact mount point
-        for mount in mounts.iter() {
+        for mount in &mounts {
             if mount.fs_file == mount_point {
                 return Ok((mount.fs_vfstype.clone(), mount.fs_spec.clone()));
             }
@@ -131,7 +132,7 @@ impl FilesystemUsage {
         let path = Path::new(mount_point);
         for ancestor in path.ancestors().skip(1) {
             if let Some(ancestor_str) = ancestor.to_str() {
-                for mount in mounts.iter() {
+                for mount in &mounts {
                     if mount.fs_file == ancestor_str {
                         return Ok((mount.fs_vfstype.clone(), mount.fs_spec.clone()));
                     }
diff --git a/src/metrics/info.rs b/src/metrics/info.rs
@@ -30,7 +30,7 @@ impl NodeInfo {
         };
 
         // SAFETY: `utsname` is initialized, and valid, and return value is checked.
-        if unsafe { nix::libc::uname(&mut utsname) } != 0 {
+        if unsafe { nix::libc::uname(&mut utsname) } != 0_i32 {
             return Err(anyhow::anyhow!("uname return an error"));
         };
 
diff --git a/src/metrics/memory.rs b/src/metrics/memory.rs
diff --git a/src/metrics/systemd_unit_state.rs b/src/metrics/systemd_unit_state.rs
diff --git a/tests/integration/config.rs b/tests/integration/config.rs
