refactor: Use serde-error to serialize error with proper backtrace in client/server boundary

Author: In-line

Cargo.lock

@@ -218,7 +218,10 @@ impl<'a, T: Deserialize<'a>> ResponseBuffer<T> {
             .context("Could not deserialize response from daemon")?;
         match response {
             Response::Ok(data) => Ok(data),
-            Response::Error(err) => Err(anyhow!("Got error from daemon: {err}")),
+            Response::Error(err) => {
+                Err(anyhow::Error::new(err)
+                    .context("Got error from daemon, end of client boundary"))
+            }
         }
     }
 }

lact-client/src/lib.rs

@@ -651,9 +651,9 @@ impl GpuController {
             }
         } else if let Ok(hw_mon) = self.first_hw_mon() {
             if let Ok(default_cap) = hw_mon.get_power_cap_default() {
-                hw_mon
-                    .set_power_cap(default_cap)
-                    .with_context(|| format!("Failed to set power cap to default cap: {default_cap}"))?;
+                hw_mon.set_power_cap(default_cap).with_context(|| {
+                    format!("Failed to set power cap to default cap: {default_cap}")
+                })?;
             }
         }
 

lact-daemon/src/server/gpu_controller/mod.rs

@@ -164,9 +164,11 @@ impl<'a> Handler {
             Err(apply_err) => {
                 error!("could not apply settings: {apply_err:?}");
                 match controller.apply_config(&gpu_config).await {
-                        Ok(()) => Err(apply_err.context("Could not apply settings")),
-                        Err(err) => Err(anyhow!("Could not apply settings, and could not reset to default settings: {err:?}")),
-                    }
+                    Ok(()) => Err(apply_err.context("Could not apply settings")),
+                    Err(err) => Err(apply_err.context(err.context(
+                        "Could not apply settings, and could not reset to default settings",
+                    ))),
+                }
             }
         }
     }

lact-daemon/src/server/handler.rs

@@ -58,11 +58,11 @@ pub async fn handle_stream(stream: UnixStream, handler: Handler) -> anyhow::Resu
         let response = match maybe_request {
             Ok(request) => match handle_request(request, &handler).await {
                 Ok(response) => response,
-                Err(error) => serde_json::to_vec(&Response::<()>::Error(format!("{error:?}")))?,
+                Err(error) => serde_json::to_vec(&Response::<()>::from(error))?,
             },
-            Err(error) => serde_json::to_vec(&Response::<()>::Error(format!(
-                "Failed to deserialize request: {error}"
-            )))?,
+            Err(error) => serde_json::to_vec(&Response::<()>::from(
+                anyhow::Error::new(error).context("Failed to deserialize"),
+            ))?,
         };
 
         stream.write_all(&response).await?;

lact-daemon/src/server/mod.rs

@@ -10,6 +10,8 @@ args = ["clap"]
 amdgpu-sysfs = { workspace = true }
 serde = { workspace = true }
 serde_with = { workspace = true }
+serde-error = "=0.1.2"
+anyhow = { workspace = true }
 
 indexmap = { version = "*", features = ["serde"] }
 clap = { version = "4.4.18", features = ["derive"], optional = true }

lact-schema/Cargo.toml

@@ -1,8 +1,14 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug)]
 #[serde(tag = "status", content = "data", rename_all = "snake_case")]
 pub enum Response<T> {
     Ok(T),
-    Error(String),
+    Error(serde_error::Error),
+}
+
+impl<T> From<anyhow::Error> for Response<T> {
+    fn from(value: anyhow::Error) -> Self {
+        Response::Error(serde_error::Error::new(&*value))
+    }
 }

lact-schema/src/response.rs

@@ -1,4 +1,5 @@
 use crate::{Pong, Request, Response};
+use anyhow::anyhow;
 use serde_json::json;
 
 #[test]
@@ -35,11 +36,24 @@ fn controllers_response() {
 #[test]
 fn error_response() {
     let expected_response = json!({
-        "status": "error",
-        "data": "my super error"
+        "data": {
+            "description": "third deeper context",
+            "source": {
+                "description": "second context",
+                "source": {
+                    "description": "first error",
+                    "source": null
+                }
+            }
+        },
+        "status": "error"
     });
 
-    let response = Response::<()>::Error("my super error".to_owned());
+    let error = anyhow!("first error")
+        .context("second context")
+        .context(anyhow!("third deeper context"));
+
+    let response = Response::<()>::from(error);
 
     assert_eq!(serde_json::to_value(response).unwrap(), expected_response);
 }