refactor: move log startup logic to lib.rs and simplify uname handling (#75)

Cleanup the main function by moving the log initialization and logging
of system information to lib.rs as functions.

Additionally, the get_kernel_version and get_architecture functions from
the host_info module have been replaced with a SystemInfo type. This
means the underlying LazyLock<HashMap> that was originally used is no
longer needed, the caller can decide what the lifetime of the object
should be and, therefore, we don't need to hang on to that information
for the entire time fact is running.

Finally, the hostname has also been added to the list of information
being logged at start up.

Author: Molter73

fact/src/host_info.rs

@@ -1,3 +1,4 @@
+use anyhow::bail;
 use log::{debug, warn};
 use std::{
     collections::HashMap,
@@ -147,50 +148,32 @@ pub fn get_distro() -> String {
     String::from("Linux")
 }
 
-const RELEASE: &str = "release";
-const MACHINE: &str = "machine";
+pub struct SystemInfo {
+    pub kernel: String,
+    pub arch: String,
+}
 
-/// Retrieve information about the kernel
-///
-/// The kernel information is retrieved by lazily calling `uname` and
-/// storing the information we care about in a hash map. This is not
-/// ideal, since the LazyLock<HashMap> will live for the entirety of
-/// the program's life, but the stored data is hopefully small enough
-/// that not calling `uname` repeatedly makes up for it.
-fn get_kernel_value(key: &str) -> Option<&String> {
-    static KERNEL_DATA: LazyLock<HashMap<&str, String>> = LazyLock::new(|| {
-        let mut map = HashMap::new();
-        let kernel_data = unsafe {
+impl SystemInfo {
+    pub fn new() -> anyhow::Result<Self> {
+        let system_info = unsafe {
             let mut info = mem::zeroed();
             let res = uname(&mut info);
             if res != 0 {
-                warn!("Failed to execute uname: {res}");
-                return map;
+                bail!(
+                    "Failed to execute uname: {}",
+                    std::io::Error::last_os_error()
+                );
             }
             info
         };
 
-        let release = unsafe { CStr::from_ptr(kernel_data.release.as_ptr()).to_str() };
-        if let Ok(release) = release {
-            map.insert(RELEASE, release.to_owned());
-        }
-        let machine = unsafe { CStr::from_ptr(kernel_data.machine.as_ptr()).to_str() };
-        if let Ok(machine) = machine {
-            map.insert(MACHINE, machine.to_owned());
-        }
-
-        map
-    });
+        let kernel = unsafe { CStr::from_ptr(system_info.release.as_ptr()) }
+            .to_string_lossy()
+            .to_string();
+        let arch = unsafe { CStr::from_ptr(system_info.machine.as_ptr()) }
+            .to_string_lossy()
+            .to_string();
 
-    KERNEL_DATA.get(key)
-}
-
-/// Same as `uname -r`
-pub fn get_kernel_version() -> &'static str {
-    get_kernel_value(RELEASE).map_or("", |s| s.as_str())
-}
-
-/// Same as `uname -m`
-pub fn get_architecture() -> &'static str {
-    get_kernel_value(MACHINE).map_or("", |s| s.as_str())
+        Ok(SystemInfo { kernel, arch })
+    }
 }

fact/src/lib.rs

@@ -1,6 +1,9 @@
+use std::{io::Write, str::FromStr};
+
 use anyhow::Context;
 use bpf::Bpf;
-use log::{debug, info};
+use host_info::{get_distro, get_hostname, SystemInfo};
+use log::{debug, info, warn, LevelFilter};
 use metrics::exporter::Exporter;
 use output::Output;
 use tokio::{
@@ -13,14 +16,52 @@ pub mod config;
 mod event;
 mod grpc;
 mod health_check;
-pub mod host_info;
+mod host_info;
 mod metrics;
 mod output;
 mod pre_flight;
 
 use config::FactConfig;
 use pre_flight::pre_flight;
 
+pub fn init_log() -> anyhow::Result<()> {
+    let log_level = std::env::var("FACT_LOGLEVEL").unwrap_or("info".to_owned());
+    let log_level = LevelFilter::from_str(&log_level)?;
+    env_logger::Builder::new()
+        .filter_level(log_level)
+        .format(move |buf, record| {
+            write!(buf, "[{:<5} {}] ", record.level(), buf.timestamp_seconds())?;
+            if matches!(log_level, LevelFilter::Debug | LevelFilter::Trace) {
+                write!(
+                    buf,
+                    "({}:{}) ",
+                    record.file().unwrap_or_default(),
+                    record.line().unwrap_or_default()
+                )?;
+            }
+            writeln!(buf, "{}", record.args())
+        })
+        .init();
+    Ok(())
+}
+
+mod version {
+    include!(concat!(env!("OUT_DIR"), "/version.rs"));
+}
+
+pub fn log_system_information() {
+    info!("fact version: {}", version::FACT_VERSION);
+    info!("OS: {}", get_distro());
+    match SystemInfo::new() {
+        Ok(sysinfo) => {
+            info!("Kernel version: {}", sysinfo.kernel);
+            info!("Architecture: {}", sysinfo.arch);
+        }
+        Err(e) => warn!("Failed to get system information: {e}"),
+    }
+    info!("Hostname: {}", get_hostname());
+}
+
 pub async fn run(config: FactConfig) -> anyhow::Result<()> {
     let (run_tx, run_rx) = watch::channel(true);
     let (tx, rx) = broadcast::channel(100);

fact/src/main.rs

@@ -1,42 +1,12 @@
-use std::io::Write;
-use std::str::FromStr;
-
-use fact::{
-    config::FactConfig,
-    host_info::{get_architecture, get_distro, get_kernel_version},
-};
-use log::{info, LevelFilter};
-
-mod version {
-    include!(concat!(env!("OUT_DIR"), "/version.rs"));
-}
+use fact::config::FactConfig;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let log_level = std::env::var("FACT_LOGLEVEL").unwrap_or("info".to_owned());
-    let log_level = LevelFilter::from_str(&log_level)?;
-    env_logger::Builder::new()
-        .filter_level(log_level)
-        .format(move |buf, record| {
-            write!(buf, "[{:<5} {}] ", record.level(), buf.timestamp_seconds())?;
-            if matches!(log_level, LevelFilter::Debug | LevelFilter::Trace) {
-                write!(
-                    buf,
-                    "({}:{}) ",
-                    record.file().unwrap_or_default(),
-                    record.line().unwrap_or_default()
-                )?;
-            }
-            writeln!(buf, "{}", record.args())
-        })
-        .init();
+    fact::init_log()?;
 
     // Log system information as early as possible so we have it
     // available in case of a crash
-    info!("fact version: {}", version::FACT_VERSION);
-    info!("OS: {}", get_distro());
-    info!("Kernel version: {}", get_kernel_version());
-    info!("Architecture: {}", get_architecture());
+    fact::log_system_information();
 
     let config = FactConfig::new(&[
         "/etc/stackrox/fact.yml",