chore(release): 0.8.2

chore(release): 0.8.1

Co-authored-by: cuddle-please <bot@cuddle.sh>
Reviewed-on: #35

CHANGELOG.md

@@ -6,6 +6,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.2] - 2025-11-13
+
+### Added
+- add publish
+- add readme
+
+### Other
+- *(deps)* update rust crate tracing-subscriber to v0.3.20 (#37)
+
+## [0.8.1] - 2025-08-09
+
+### Other
+- error logging
+
 ## [0.8.0] - 2025-08-08
 
 ### Added

Cargo.lock

@@ -242,11 +242,11 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "matchers"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.1.10",
+ "regex-automata",
 ]
 
 [[package]]
@@ -273,12 +273,12 @@ dependencies = [
  "hermit-abi",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "notmad"
-version = "0.7.5"
+version = "0.8.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -295,12 +295,11 @@ dependencies = [
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -318,12 +317,6 @@ version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
 [[package]]
 name = "parking_lot"
 version = "0.12.3"
@@ -425,27 +418,6 @@ dependencies = [
  "bitflags",
 ]
 
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata 0.4.9",
- "regex-syntax 0.8.5",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
-]
-
 [[package]]
 name = "regex-automata"
 version = "0.4.9"
@@ -454,15 +426,9 @@ checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.5",
+ "regex-syntax",
 ]
 
-[[package]]
-name = "regex-syntax"
-version = "0.6.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -521,7 +487,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -582,7 +548,7 @@ dependencies = [
  "slab",
  "socket2",
  "tokio-macros",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -655,14 +621,14 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata",
  "sharded-slab",
  "smallvec",
  "thread_local",
@@ -720,26 +686,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "winapi"
-version = "0.3.9"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-sys"
@@ -750,6 +700,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.8.0"
+version = "0.8.2"
 
 [workspace.dependencies]
 mad = { path = "crates/mad" }

crates/mad/Cargo.toml

@@ -6,6 +6,7 @@ license = "MIT"
 repository = "https://github.com/kjuulh/mad"
 authors = ["kjuulh"]
 edition = "2024"
+readme = "../../README.md"
 
 [dependencies]
 anyhow.workspace = true

crates/mad/examples/nested_errors/main.rs

@@ -0,0 +1,86 @@
+use async_trait::async_trait;
+use tokio_util::sync::CancellationToken;
+
+struct NestedErrorComponent {
+    name: String,
+}
+
+#[async_trait]
+impl notmad::Component for NestedErrorComponent {
+    fn name(&self) -> Option<String> {
+        Some(self.name.clone())
+    }
+
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+        // Simulate a deeply nested error
+        let io_error = std::io::Error::new(
+            std::io::ErrorKind::PermissionDenied,
+            "access denied to /etc/secret",
+        );
+
+        Err(anyhow::Error::from(io_error)
+            .context("failed to read configuration file")
+            .context("unable to initialize database connection pool")
+            .context(format!("component '{}' startup failed", self.name))
+            .into())
+    }
+}
+
+struct AnotherFailingComponent;
+
+#[async_trait]
+impl notmad::Component for AnotherFailingComponent {
+    fn name(&self) -> Option<String> {
+        Some("another-component".into())
+    }
+
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+        Err(anyhow::anyhow!("network timeout after 30s")
+            .context("failed to connect to external API")
+            .context("service health check failed")
+            .into())
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter("mad=debug")
+        .init();
+
+    let result = notmad::Mad::builder()
+        .add(NestedErrorComponent {
+            name: "database-service".into(),
+        })
+        .add(AnotherFailingComponent)
+        .run()
+        .await;
+
+    match result {
+        Ok(()) => println!("Success!"),
+        Err(e) => {
+            eprintln!("\n=== Error occurred ===");
+            eprintln!("{}", e);
+
+            // Also demonstrate how to walk the error chain manually
+            if let notmad::MadError::AggregateError(ref agg) = e {
+                eprintln!("\n=== Detailed error chains ===");
+                for (i, error) in agg.get_errors().iter().enumerate() {
+                    eprintln!("\nComponent {} error chain:", i + 1);
+                    if let notmad::MadError::Inner(inner) = error {
+                        for (j, cause) in inner.chain().enumerate() {
+                            eprintln!("  {}. {}", j + 1, cause);
+                        }
+                    }
+                }
+            } else if let notmad::MadError::Inner(ref inner) = e {
+                eprintln!("\n=== Error chain ===");
+                for (i, cause) in inner.chain().enumerate() {
+                    eprintln!("  {}. {}", i + 1, cause);
+                }
+            }
+        }
+    }
+}

crates/mad/src/lib.rs

@@ -77,7 +77,7 @@
 
 use futures::stream::FuturesUnordered;
 use futures_util::StreamExt;
-use std::{fmt::Display, sync::Arc};
+use std::{fmt::Display, sync::Arc, error::Error};
 use tokio::signal::unix::{SignalKind, signal};
 
 use tokio_util::sync::CancellationToken;
@@ -96,22 +96,27 @@ pub enum MadError {
     ///
     /// This variant is used when components return errors via the `?` operator
     /// or when converting from `anyhow::Error`.
-    #[error("component: {0:#?}")]
-    Inner(#[source] anyhow::Error),
+    #[error(transparent)]
+    Inner(anyhow::Error),
 
     /// Error that occurred during the run phase of a component.
-    #[error("component: {run:#?}")]
-    RunError { run: anyhow::Error },
+    #[error(transparent)]
+    RunError { 
+        run: anyhow::Error 
+    },
 
     /// Error that occurred during the close phase of a component.
-    #[error("component(s) failed: {close}")]
-    CloseError { close: anyhow::Error },
+    #[error("component(s) failed during close")]
+    CloseError { 
+        #[source]
+        close: anyhow::Error 
+    },
 
     /// Multiple errors from different components.
     ///
     /// This is used when multiple components fail simultaneously,
     /// allowing all errors to be reported rather than just the first one.
-    #[error("component(s): {0}")]
+    #[error("{0}")]
     AggregateError(AggregateError),
 
     /// Returned when a component doesn't implement the optional setup method.
@@ -137,7 +142,7 @@ impl From<anyhow::Error> for MadError {
 ///
 /// When multiple components fail, their errors are collected
 /// into this struct to provide complete error reporting.
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub struct AggregateError {
     errors: Vec<MadError>,
 }
@@ -169,17 +174,23 @@ impl Display for AggregateError {
         }
 
         if self.errors.len() == 1 {
-            return f.write_str(&self.errors.first().unwrap().to_string());
+            return write!(f, "{}", self.errors[0]);
         }
 
-        f.write_str("MadError::AggregateError: (")?;
-
-        for error in &self.errors {
-            f.write_str(&error.to_string())?;
-            f.write_str(", ")?;
+        writeln!(f, "{} component errors occurred:", self.errors.len())?;
+        for (i, error) in self.errors.iter().enumerate() {
+            write!(f, "\n[Component {}] {}", i + 1, error)?;
+            
+            // Print the error chain for each component error
+            let mut source = error.source();
+            let mut level = 1;
+            while let Some(err) = source {
+                write!(f, "\n  {}. {}", level, err)?;
+                source = err.source();
+                level += 1;
+            }
         }
-
-        f.write_str(")")
+        Ok(())
     }
 }
 
@@ -771,3 +782,132 @@ where
         self.execute(cancellation_token).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Context;
+
+    #[test]
+    fn test_error_chaining_display() {
+        // Test single error with context chain
+        let base_error = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
+        let error = anyhow::Error::from(base_error)
+            .context("failed to read configuration")
+            .context("unable to initialize database")
+            .context("service startup failed");
+        
+        let mad_error = MadError::Inner(error);
+        let display = format!("{}", mad_error);
+        
+        // Should display the top-level error message
+        assert!(display.contains("service startup failed"));
+        
+        // Test error chain iteration
+        if let MadError::Inner(ref e) = mad_error {
+            let chain: Vec<String> = e.chain().map(|c| c.to_string()).collect();
+            assert_eq!(chain.len(), 4);
+            assert_eq!(chain[0], "service startup failed");
+            assert_eq!(chain[1], "unable to initialize database");
+            assert_eq!(chain[2], "failed to read configuration");
+            assert_eq!(chain[3], "file not found");
+        }
+    }
+
+    #[test]
+    fn test_aggregate_error_display() {
+        let error1 = MadError::Inner(
+            anyhow::anyhow!("database connection failed")
+                .context("failed to connect to PostgreSQL")
+        );
+        
+        let error2 = MadError::Inner(
+            anyhow::anyhow!("port already in use")
+                .context("failed to bind to port 8080")
+                .context("web server initialization failed")
+        );
+        
+        let aggregate = MadError::AggregateError(AggregateError {
+            errors: vec![error1, error2],
+        });
+        
+        let display = format!("{}", aggregate);
+        
+        // Check that it shows multiple errors
+        assert!(display.contains("2 component errors occurred"));
+        assert!(display.contains("[Component 1]"));
+        assert!(display.contains("[Component 2]"));
+        
+        // Check that context chains are displayed
+        assert!(display.contains("failed to connect to PostgreSQL"));
+        assert!(display.contains("database connection failed"));
+        assert!(display.contains("web server initialization failed"));
+        assert!(display.contains("failed to bind to port 8080"));
+        assert!(display.contains("port already in use"));
+    }
+
+    #[test]
+    fn test_single_error_aggregate() {
+        let error = MadError::Inner(anyhow::anyhow!("single error"));
+        let aggregate = AggregateError {
+            errors: vec![error],
+        };
+        
+        let display = format!("{}", aggregate);
+        // Single error should be displayed directly
+        assert!(display.contains("single error"));
+        assert!(!display.contains("component errors occurred"));
+    }
+
+    #[test]
+    fn test_error_source_chain() {
+        let error = MadError::Inner(
+            anyhow::anyhow!("root cause")
+                .context("middle layer")
+                .context("top layer")
+        );
+        
+        // Test that we can access the error chain
+        if let MadError::Inner(ref e) = error {
+            let chain: Vec<String> = e.chain().map(|c| c.to_string()).collect();
+            assert_eq!(chain.len(), 3);
+            assert_eq!(chain[0], "top layer");
+            assert_eq!(chain[1], "middle layer");
+            assert_eq!(chain[2], "root cause");
+        } else {
+            panic!("Expected MadError::Inner");
+        }
+    }
+
+    #[tokio::test]
+    async fn test_component_error_propagation() {
+        struct FailingComponent;
+        
+        #[async_trait::async_trait]
+        impl Component for FailingComponent {
+            fn name(&self) -> Option<String> {
+                Some("test-component".to_string())
+            }
+            
+            async fn run(&self, _cancel: CancellationToken) -> Result<(), MadError> {
+                Err(anyhow::anyhow!("IO error")
+                    .context("failed to open file")
+                    .context("component initialization failed")
+                    .into())
+            }
+        }
+        
+        let result = Mad::builder()
+            .add(FailingComponent)
+            .cancellation(Some(std::time::Duration::from_millis(100)))
+            .run()
+            .await;
+        
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+        
+        // Check error display
+        let display = format!("{}", error);
+        assert!(display.contains("component initialization failed"));
+    }
+}

cuddle.yaml

@@ -5,6 +5,8 @@ base: "git@git.kjuulh.io:kjuulh/cuddle-rust-lib-plan.git"
 vars:
   service: "mad"
   registry: kasperhermansen
+  rust:
+    publish: {}
 
 please:
   project: