fix(deps): update all dependencies

2025-11-13 04:32:29 +00:00
15 changed files with 353 additions and 436 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,24 +6,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

-## [0.10.0] - 2025-11-15
-
-### Added
- implement take errors
-
-## [0.9.0] - 2025-11-15
-
-### Added
- mad not properly surfaces panics
- add publish
- add readme
-
-### Fixed
- *(deps)* update all dependencies (#38)
-
-### Other
- *(deps)* update rust crate tracing-subscriber to v0.3.20 (#37)
-
 ## [0.8.1] - 2025-08-09

 ### Other
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13,9 +13,20 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.101"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]

 [[package]]
 name = "autocfg"
@@ -211,9 +222,10 @@ dependencies = [

 [[package]]
 name = "notmad"
-version = "0.11.0"
+version = "0.8.1"
 dependencies = [
 "anyhow",
+ "async-trait",
 "futures",
 "futures-util",
 "rand",
@@ -420,18 +432,18 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "2.0.18"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "2.0.18"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -450,9 +462,9 @@ dependencies = [

 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
 dependencies = [
 "bytes",
 "libc",
@@ -478,9 +490,9 @@ dependencies = [

 [[package]]
 name = "tokio-util"
-version = "0.7.18"
+version = "0.7.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
 dependencies = [
 "bytes",
 "futures-core",
@@ -491,9 +503,9 @@ dependencies = [

 [[package]]
 name = "tracing"
-version = "0.1.44"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
 "log",
 "pin-project-lite",
@@ -503,9 +515,9 @@ dependencies = [

 [[package]]
 name = "tracing-attributes"
-version = "0.1.31"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -514,9 +526,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.36"
+version = "0.1.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
 dependencies = [
 "once_cell",
 "valuable",
@@ -535,9 +547,9 @@ dependencies = [

 [[package]]
 name = "tracing-subscriber"
-version = "0.3.22"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
 "matchers",
 "nu-ansi-term",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,9 +3,10 @@ members = ["crates/*"]
 resolver = "2"

 [workspace.package]
-version = "0.11.0"
+version = "0.8.1"

 [workspace.dependencies]
+mad = { path = "crates/mad" }

 anyhow = { version = "1.0.71" }
 tokio = { version = "1", features = ["full"] }
--- a/README.md
+++ b/README.md
@@ -4,163 +4,165 @@
 [![Documentation](https://docs.rs/notmad/badge.svg)](https://docs.rs/notmad)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

-A simple lifecycle manager for long-running Rust applications. Run multiple services concurrently with graceful shutdown handling.
+## Overview
+
+MAD is a robust lifecycle manager designed for long-running Rust operations. It provides a simple, composable way to manage multiple concurrent services within your application, handling graceful startup and shutdown automatically.
+
+### Perfect for:
+- 🌐 Web servers
+- 📨 Queue consumers and message processors  
+- 🔌 gRPC servers
+- ⏰ Cron job runners
+- 🔄 Background workers
+- 📡 Any long-running async operations
+
+## Features
+
+- **Component-based architecture** - Build your application from composable, reusable components
+- **Graceful shutdown** - Automatic handling of shutdown signals with proper cleanup
+- **Concurrent execution** - Run multiple components in parallel with tokio
+- **Error handling** - Built-in error propagation and logging
+- **Cancellation tokens** - Coordinate shutdown across all components
+- **Minimal boilerplate** - Focus on your business logic, not lifecycle management

 ## Installation

+Add MAD to your `Cargo.toml`:
+
 ```toml
 [dependencies]
-notmad = "0.10.0"
+notmad = "0.7.5"
 tokio = { version = "1", features = ["full"] }
+async-trait = "0.1"
 ```

 ## Quick Start

+Here's a simple example of a component that simulates a long-running server:
+
 ```rust
-use notmad::{Component, Mad};
+use mad::{Component, Mad};
+use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;

-struct MyService;
+// Define your component
+struct WebServer {
+    port: u16,
+}
+
+#[async_trait]
+impl Component for WebServer {
+    fn name(&self) -> Option<String> {
+        Some(format!("WebServer on port {}", self.port))
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        println!("Starting web server on port {}", self.port);
+        
+        // Your server logic here
+        // The cancellation token will be triggered on shutdown
+        tokio::select! {
+            _ = cancellation.cancelled() => {
+                println!("Shutting down web server");
+            }
+            _ = self.serve() => {
+                println!("Server stopped");
+            }
+        }
        
-impl Component for MyService {
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
-        println!("Service running...");
-        cancellation.cancelled().await;
-        println!("Service stopped");
        Ok(())
    }
 }

+impl WebServer {
+    async fn serve(&self) {
+        // Simulate a running server
+        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
+    }
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    // Build and run your application
    Mad::builder()
-        .add(MyService)
+        .add(WebServer { port: 8080 })
+        .add(WebServer { port: 8081 })  // You can add multiple instances
        .run()
        .await?;
+
    Ok(())
 }
 ```

-## Basic Usage
+## Advanced Usage

-### Axum Web Server with Graceful Shutdown
+### Custom Components

-Here's how to run an Axum server with MAD's graceful shutdown:
+Components can be anything that implements the `Component` trait:

 ```rust
-use axum::{Router, routing::get};
-use notmad::{Component, ComponentInfo};
-use tokio_util::sync::CancellationToken;
+use mad::{Component, Mad};
+use async_trait::async_trait;

-struct WebServer {
-    port: u16,
+struct QueueProcessor {
+    queue_name: String,
 }

-impl Component for WebServer {
-    fn info(&self) -> ComponentInfo {
-        format!("WebServer:{}", self.port).into()
+#[async_trait]
+impl Component for QueueProcessor {
+    fn name(&self) -> Option<String> {
+        Some(format!("QueueProcessor-{}", self.queue_name))
    }

-    async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
-        let app = Router::new().route("/", get(|| async { "Hello, World!" }));
-
-        let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", self.port))
-            .await?;
-
-        println!("Listening on http://0.0.0.0:{}", self.port);
-
-        // Run server with graceful shutdown
-        axum::serve(listener, app)
-            .with_graceful_shutdown(async move {
-                cancel.cancelled().await;
-                println!("Shutting down server...");
-            })
-            .await?;
-
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        while !cancellation.is_cancelled() {
+            // Process messages from queue
+            self.process_next_message().await?;
+        }
        Ok(())
    }
 }
 ```

-### Run Multiple Services
+### Error Handling
+
+MAD provides comprehensive error handling through the `MadError` type with automatic conversion from `anyhow::Error`:

 ```rust
-Mad::builder()
-    .add(WebServer { port: 8080 })
-    .add(WebServer { port: 8081 })
-    .run()
-    .await?;
-```
+async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+    // Errors automatically convert from anyhow::Error to MadError
+    database_operation().await?;
    
-### Use Functions as Components
-
-```rust
-Mad::builder()
-    .add_fn(|cancel| async move {
-        println!("Running...");
-        cancel.cancelled().await;
-        Ok(())
-    })
-    .run()
-    .await?;
-```
-
-## Lifecycle Hooks
-
-Components support optional setup and cleanup phases:
-
-```rust
-impl Component for DatabaseService {
-    async fn setup(&self) -> Result<(), notmad::MadError> {
-        println!("Connecting to database...");
-        Ok(())
+    // Or return explicit errors
+    if some_condition {
+        return Err(anyhow::anyhow!("Something went wrong").into());
    }
    
-    async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
-        cancel.cancelled().await;
-        Ok(())
-    }
-
-    async fn close(&self) -> Result<(), notmad::MadError> {
-        println!("Closing database connection...");
-        Ok(())
-    }
+    Ok(())
 }
 ```

-## Migration from v0.10
-
-### Breaking Changes
-
-1. **`name()` → `info()`**: Returns `ComponentInfo` instead of `Option<String>`
-   ```rust
-   // Before
-   fn name(&self) -> Option<String> { Some("my-service".into()) }
-
-   // After
-   fn info(&self) -> ComponentInfo { "my-service".into() }
-   ```
-
-2. **No more `async-trait`**: Remove the dependency and `#[async_trait]` attribute
-   ```rust
-   // Before
-   #[async_trait]
-   impl Component for MyService { }
-
-   // After
-   impl Component for MyService { }
-   ```
-
 ## Examples

-See [examples directory](crates/mad/examples) for complete working examples.
+Check out the [examples directory](crates/mad/examples) for more detailed examples:
+
+- **basic** - Simple component lifecycle
+- **fn** - Using functions as components
+- **signals** - Handling system signals
+- **error_log** - Error handling and logging
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

 ## License

-MIT - see [LICENSE](LICENSE)
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

-## Links
+## Author

- [Documentation](https://docs.rs/notmad)
- [Repository](https://github.com/kjuulh/mad)
- [Crates.io](https://crates.io/crates/notmad)
+Created and maintained by [kjuulh](https://github.com/kjuulh)
+
+## Repository
+
+Find the source code at [https://github.com/kjuulh/mad](https://github.com/kjuulh/mad)
--- a/crates/mad/Cargo.toml
+++ b/crates/mad/Cargo.toml
@@ -10,6 +10,7 @@ readme = "../../README.md"

 [dependencies]
 anyhow.workspace = true
+async-trait = "0.1.81"
 futures = "0.3.30"
 futures-util = "0.3.30"
 rand = "0.9.0"
--- a/crates/mad/examples/basic/main.rs
+++ b/crates/mad/examples/basic/main.rs
@@ -1,15 +1,16 @@
-use notmad::ComponentInfo;
+use async_trait::async_trait;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;

 struct WaitServer {}
+#[async_trait]
 impl notmad::Component for WaitServer {
-    fn info(&self) -> ComponentInfo {
-        "WaitServer".into()
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
    }

-    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
        let millis_wait = rand::thread_rng().gen_range(500..3000);

        tracing::debug!("waiting: {}ms", millis_wait);
--- a/crates/mad/examples/comprehensive/main.rs
+++ b/crates/mad/examples/comprehensive/main.rs
@@ -7,7 +7,8 @@
 //! - Graceful shutdown with cancellation tokens
 //! - Concurrent component execution

-use notmad::{Component, ComponentInfo, Mad, MadError};
+use async_trait::async_trait;
+use notmad::{Component, Mad, MadError};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio::time::{Duration, interval};
@@ -20,9 +21,10 @@ struct WebServer {
    request_count: Arc<AtomicUsize>,
 }

+#[async_trait]
 impl Component for WebServer {
-    fn info(&self) -> ComponentInfo {
-        format!("web-server-{}", self.port).into()
+    fn name(&self) -> Option<String> {
+        Some(format!("web-server-{}", self.port))
    }

    async fn setup(&self) -> Result<(), MadError> {
@@ -79,9 +81,10 @@ struct JobProcessor {
    processing_interval: Duration,
 }

+#[async_trait]
 impl Component for JobProcessor {
-    fn info(&self) -> ComponentInfo {
-        format!("job-processor-{}", self.queue_name).into()
+    fn name(&self) -> Option<String> {
+        Some(format!("job-processor-{}", self.queue_name))
    }

    async fn setup(&self) -> Result<(), MadError> {
@@ -136,9 +139,10 @@ struct HealthChecker {
    check_interval: Duration,
 }

+#[async_trait]
 impl Component for HealthChecker {
-    fn info(&self) -> ComponentInfo {
-        "health-checker".into()
+    fn name(&self) -> Option<String> {
+        Some("health-checker".to_string())
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
@@ -177,9 +181,10 @@ struct FailingComponent {
    fail_after: Duration,
 }

+#[async_trait]
 impl Component for FailingComponent {
-    fn info(&self) -> ComponentInfo {
-        "failing-component".into()
+    fn name(&self) -> Option<String> {
+        Some("failing-component".to_string())
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
@@ -204,9 +209,10 @@ impl Component for FailingComponent {
 /// Debug component that logs system status periodically.
 struct DebugComponent;

+#[async_trait]
 impl Component for DebugComponent {
-    fn info(&self) -> ComponentInfo {
-        "debug-component".into()
+    fn name(&self) -> Option<String> {
+        Some("debug-component".to_string())
    }

    async fn run(&self, cancel: CancellationToken) -> Result<(), MadError> {
--- a/crates/mad/examples/error_log/main.rs
+++ b/crates/mad/examples/error_log/main.rs
@@ -1,15 +1,16 @@
-use notmad::ComponentInfo;
+use async_trait::async_trait;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;

 struct ErrorServer {}
+#[async_trait]
 impl notmad::Component for ErrorServer {
-    fn info(&self) -> ComponentInfo {
-        "ErrorServer".into()
+    fn name(&self) -> Option<String> {
+        Some("ErrorServer".into())
    }

-    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
        let millis_wait = rand::thread_rng().gen_range(500..3000);

        tracing::debug!("waiting: {}ms", millis_wait);
--- a/crates/mad/examples/fn/main.rs
+++ b/crates/mad/examples/fn/main.rs
@@ -1,12 +1,13 @@
-use notmad::ComponentInfo;
+use async_trait::async_trait;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;

 struct WaitServer {}
+#[async_trait]
 impl notmad::Component for WaitServer {
-    fn info(&self) -> ComponentInfo {
-        "WaitServer".into()
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
    }

    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
--- a/crates/mad/examples/multi_service/main.rs
+++ b/crates/mad/examples/multi_service/main.rs
@@ -3,7 +3,8 @@
 //! This example shows how to run a web server, queue processor, and
 //! scheduled task together, with graceful shutdown on Ctrl+C.

-use notmad::{Component, ComponentInfo, Mad, MadError};
+use async_trait::async_trait;
+use notmad::{Component, Mad, MadError};
 use tokio::time::{Duration, interval};
 use tokio_util::sync::CancellationToken;

@@ -15,21 +16,22 @@ struct WebServer {
    port: u16,
 }

+#[async_trait]
 impl Component for WebServer {
-    fn info(&self) -> ComponentInfo {
-        format!("WebServer:{}", self.port).into()
+    fn name(&self) -> Option<String> {
+        Some(format!("WebServer:{}", self.port))
    }

    async fn setup(&self) -> Result<(), MadError> {
-        println!("[{}] Binding to port...", self.info());
+        println!("[{}] Binding to port...", self.name().unwrap());
        // Simulate server setup time
        tokio::time::sleep(Duration::from_millis(100)).await;
-        println!("[{}] Ready to accept connections", self.info());
+        println!("[{}] Ready to accept connections", self.name().unwrap());
        Ok(())
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
-        println!("[{}] Server started", self.info());
+        println!("[{}] Server started", self.name().unwrap());

        // Simulate handling requests until shutdown
        let mut request_id = 0;
@@ -38,12 +40,12 @@ impl Component for WebServer {
        while !cancellation.is_cancelled() {
            tokio::select! {
                _ = cancellation.cancelled() => {
-                    println!("[{}] Shutdown signal received", self.info());
+                    println!("[{}] Shutdown signal received", self.name().unwrap());
                    break;
                }
                _ = interval.tick() => {
                    request_id += 1;
-                    println!("[{}] Handling request #{}", self.info(), request_id);
+                    println!("[{}] Handling request #{}", self.name().unwrap(), request_id);
                }
            }
        }
@@ -52,10 +54,10 @@ impl Component for WebServer {
    }

    async fn close(&self) -> Result<(), MadError> {
-        println!("[{}] Closing connections...", self.info());
+        println!("[{}] Closing connections...", self.name().unwrap());
        // Simulate graceful connection drain
        tokio::time::sleep(Duration::from_millis(200)).await;
-        println!("[{}] Server stopped", self.info());
+        println!("[{}] Server stopped", self.name().unwrap());
        Ok(())
    }
 }
@@ -68,13 +70,14 @@ struct QueueProcessor {
    queue_name: String,
 }

+#[async_trait]
 impl Component for QueueProcessor {
-    fn info(&self) -> ComponentInfo {
-        format!("QueueProcessor:{}", self.queue_name).into()
+    fn name(&self) -> Option<String> {
+        Some(format!("QueueProcessor:{}", self.queue_name))
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
-        println!("[{}] Started processing", self.info());
+        println!("[{}] Started processing", self.name().unwrap());

        let mut message_count = 0;

@@ -83,19 +86,19 @@ impl Component for QueueProcessor {
            // Simulate waiting for and processing a message
            tokio::select! {
                _ = cancellation.cancelled() => {
-                    println!("[{}] Stopping message processing", self.info());
+                    println!("[{}] Stopping message processing", self.name().unwrap());
                    break;
                }
                _ = tokio::time::sleep(Duration::from_secs(1)) => {
                    message_count += 1;
-                    println!("[{}] Processed message #{}", self.info(), message_count);
+                    println!("[{}] Processed message #{}", self.name().unwrap(), message_count);
                }
            }
        }

        println!(
            "[{}] Processed {} messages total",
-            self.info(),
+            self.name().unwrap(),
            message_count
        );
        Ok(())
@@ -113,15 +116,16 @@ struct ScheduledTask {
    interval_secs: u64,
 }

+#[async_trait]
 impl Component for ScheduledTask {
-    fn info(&self) -> ComponentInfo {
-        format!("ScheduledTask:{}", self.task_name).into()
+    fn name(&self) -> Option<String> {
+        Some(format!("ScheduledTask:{}", self.task_name))
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
        println!(
            "[{}] Scheduled to run every {} seconds",
-            self.info(),
+            self.name().unwrap(),
            self.interval_secs
        );

@@ -131,17 +135,17 @@ impl Component for ScheduledTask {
        while !cancellation.is_cancelled() {
            tokio::select! {
                _ = cancellation.cancelled() => {
-                    println!("[{}] Scheduler stopping", self.info());
+                    println!("[{}] Scheduler stopping", self.name().unwrap());
                    break;
                }
                _ = interval.tick() => {
                    run_count += 1;
-                    println!("[{}] Executing run #{}", self.info(), run_count);
+                    println!("[{}] Executing run #{}", self.name().unwrap(), run_count);

                    // Simulate task execution
                    tokio::time::sleep(Duration::from_millis(500)).await;

-                    println!("[{}] Run #{} completed", self.info(), run_count);
+                    println!("[{}] Run #{} completed", self.name().unwrap(), run_count);
                }
            }
        }
--- a/crates/mad/examples/nested_errors/main.rs
+++ b/crates/mad/examples/nested_errors/main.rs
@@ -1,13 +1,14 @@
-use notmad::ComponentInfo;
+use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;

 struct NestedErrorComponent {
    name: String,
 }

+#[async_trait]
 impl notmad::Component for NestedErrorComponent {
-    fn info(&self) -> ComponentInfo {
-        self.name.clone().into()
+    fn name(&self) -> Option<String> {
+        Some(self.name.clone())
    }

    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
@@ -27,9 +28,10 @@ impl notmad::Component for NestedErrorComponent {

 struct AnotherFailingComponent;

+#[async_trait]
 impl notmad::Component for AnotherFailingComponent {
-    fn info(&self) -> ComponentInfo {
-        "another-component".into()
+    fn name(&self) -> Option<String> {
+        Some("another-component".into())
    }

    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
--- a/crates/mad/examples/signals/main.rs
+++ b/crates/mad/examples/signals/main.rs
@@ -1,15 +1,16 @@
-use notmad::ComponentInfo;
+use async_trait::async_trait;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;

 struct WaitServer {}
+#[async_trait]
 impl notmad::Component for WaitServer {
-    fn info(&self) -> ComponentInfo {
-        "WaitServer".into()
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
    }

-    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
        let millis_wait = rand::thread_rng().gen_range(500..3000);

        tracing::debug!("waiting: {}ms", millis_wait);
@@ -22,9 +23,10 @@ impl notmad::Component for WaitServer {
 }

 struct RespectCancel {}
+#[async_trait]
 impl notmad::Component for RespectCancel {
-    fn info(&self) -> ComponentInfo {
-        "RespectCancel".into()
+    fn name(&self) -> Option<String> {
+        Some("RespectCancel".into())
    }

    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
@@ -36,12 +38,13 @@ impl notmad::Component for RespectCancel {
 }

 struct NeverStopServer {}
+#[async_trait]
 impl notmad::Component for NeverStopServer {
-    fn info(&self) -> ComponentInfo {
-        "NeverStopServer".into()
+    fn name(&self) -> Option<String> {
+        Some("NeverStopServer".into())
    }

-    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
        tokio::time::sleep(std::time::Duration::from_millis(999999999)).await;

--- a/crates/mad/src/lib.rs
+++ b/crates/mad/src/lib.rs
@@ -1,21 +1,42 @@
 //! # MAD - Lifecycle Manager for Rust Applications
 //!
-//! A simple lifecycle manager for long-running Rust applications. Run multiple services
-//! concurrently with graceful shutdown handling.
+//! MAD is a robust lifecycle manager designed for long-running Rust operations. It provides
+//! a simple, composable way to manage multiple concurrent services within your application,
+//! handling graceful startup and shutdown automatically.
+//!
+//! ## Overview
+//!
+//! MAD helps you build applications composed of multiple long-running components that need
+//! to be orchestrated together. It handles:
+//!
+//! - **Concurrent execution** of multiple components
+//! - **Graceful shutdown** with cancellation tokens
+//! - **Error aggregation** from multiple components
+//! - **Lifecycle management** with setup, run, and close phases
 //!
 //! ## Quick Start
 //!
 //! ```rust,no_run
 //! use notmad::{Component, Mad};
+//! use async_trait::async_trait;
 //! use tokio_util::sync::CancellationToken;
 //!
-//! struct MyService;
+//! struct MyService {
+//!     name: String,
+//! }
 //!
+//! #[async_trait]
 //! impl Component for MyService {
-//!     async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
-//!         println!("Running...");
-//!         cancel.cancelled().await;
-//!         println!("Stopped");
+//!     fn name(&self) -> Option<String> {
+//!         Some(self.name.clone())
+//!     }
+//!
+//!     async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+//!         // Your service logic here
+//!         while !cancellation.is_cancelled() {
+//!             // Do work...
+//!             tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+//!         }
 //!         Ok(())
 //!     }
 //! }
@@ -23,24 +44,40 @@
 //! #[tokio::main]
 //! async fn main() -> anyhow::Result<()> {
 //!     Mad::builder()
-//!         .add(MyService)
+//!         .add(MyService { name: "service-1".into() })
+//!         .add(MyService { name: "service-2".into() })
 //!         .run()
 //!         .await?;
 //!     Ok(())
 //! }
 //! ```
 //!
-//! ## Features
+//! ## Component Lifecycle
 //!
-//! - Run multiple components concurrently
-//! - Graceful shutdown with cancellation tokens
-//! - Optional lifecycle hooks: `setup()`, `run()`, `close()`
-//! - Automatic error aggregation
-//! - SIGTERM and Ctrl+C signal handling
+//! Components go through three phases:
+//!
+//! 1. **Setup**: Optional initialization phase before components start running
+//! 2. **Run**: Main execution phase where components perform their work
+//! 3. **Close**: Optional cleanup phase after components stop
+//!
+//! ## Error Handling
+//!
+//! MAD provides comprehensive error handling through [`MadError`], which can:
+//! - Wrap errors from individual components
+//! - Aggregate multiple errors when several components fail
+//! - Automatically convert from `anyhow::Error`
+//!
+//! ## Shutdown Behavior
+//!
+//! MAD handles shutdown gracefully:
+//! - Responds to SIGTERM and Ctrl+C signals
+//! - Propagates cancellation tokens to all components
+//! - Waits for components to finish cleanup
+//! - Configurable cancellation timeout

 use futures::stream::FuturesUnordered;
 use futures_util::StreamExt;
-use std::{error::Error, fmt::Display, pin::Pin, sync::Arc};
+use std::{fmt::Display, sync::Arc, error::Error};
 use tokio::signal::unix::{SignalKind, signal};

 use tokio_util::sync::CancellationToken;
@@ -64,13 +101,15 @@ pub enum MadError {

    /// Error that occurred during the run phase of a component.
    #[error(transparent)]
-    RunError { run: anyhow::Error },
+    RunError { 
+        run: anyhow::Error 
+    },

    /// Error that occurred during the close phase of a component.
    #[error("component(s) failed during close")]
    CloseError { 
        #[source]
-        close: anyhow::Error,
+        close: anyhow::Error 
    },

    /// Multiple errors from different components.
@@ -126,10 +165,6 @@ impl AggregateError {
    pub fn get_errors(&self) -> &[MadError] {
        &self.errors
    }
-
-    pub fn take_errors(self) -> Vec<MadError> {
-        self.errors
-    }
 }

 impl Display for AggregateError {
@@ -168,10 +203,12 @@ impl Display for AggregateError {
 ///
 /// ```rust
 /// use notmad::{Component, Mad};
+/// use async_trait::async_trait;
 /// use tokio_util::sync::CancellationToken;
 ///
 /// struct MyComponent;
 ///
+/// #[async_trait]
 /// impl Component for MyComponent {
 ///     async fn run(&self, _cancel: CancellationToken) -> Result<(), notmad::MadError> {
 ///         Ok(())
@@ -187,7 +224,7 @@ impl Display for AggregateError {
 /// # }
 /// ```
 pub struct Mad {
-    components: Vec<SharedComponent>,
+    components: Vec<Arc<dyn Component + Send + Sync + 'static>>,

    should_cancel: Option<std::time::Duration>,
 }
@@ -231,8 +268,10 @@ impl Mad {
    ///
    /// ```rust
    /// use notmad::{Component, Mad};
+    /// # use async_trait::async_trait;
    /// # use tokio_util::sync::CancellationToken;
    /// # struct MyService;
+    /// # #[async_trait]
    /// # impl Component for MyService {
    /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
    /// # }
@@ -262,8 +301,10 @@ impl Mad {
    /// ```rust
    /// use notmad::Mad;
    /// # use notmad::Component;
+    /// # use async_trait::async_trait;
    /// # use tokio_util::sync::CancellationToken;
    /// # struct DebugService;
+    /// # #[async_trait]
    /// # impl Component for DebugService {
    /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
    /// # }
@@ -351,7 +392,7 @@ impl Mad {
    /// # Arguments
    ///
    /// * `should_cancel` - Duration to wait after cancellation before forcing shutdown.
-    ///   Pass `None` to wait indefinitely.
+    ///                     Pass `None` to wait indefinitely.
    ///
    /// # Example
    ///
@@ -426,7 +467,7 @@ impl Mad {
        tracing::debug!("setting up components");

        for comp in &self.components {
-            tracing::trace!(component = %comp.info(), "mad setting up");
+            tracing::trace!(component = &comp.name(), "mad setting up");

            match comp.setup().await {
                Ok(_) | Err(MadError::SetupNotDefined) => {}
@@ -456,37 +497,16 @@ impl Mad {
            channels.push(error_rx);

            tokio::spawn(async move {
-                let info = comp.info().clone();
+                let name = comp.name().clone();

-                tracing::debug!(component = %info, "mad running");
-
-                let handle = tokio::spawn(async move { comp.run(job_cancellation).await });
+                tracing::debug!(component = name, "mad running");

                tokio::select! {
                    _ = cancellation_token.cancelled() => {
-                        error_tx.send(CompletionResult { res: Ok(()) , name: info.name  }).await
+                        error_tx.send(CompletionResult { res: Ok(()) , name  }).await
                    }
-                    res = handle => {
-                     let res = match res {
-                         Ok(res) => res,
-                         Err(join) => {
-                             match join.source() {
-                                 Some(error) => {
-                                     Err(MadError::RunError{run: anyhow::anyhow!("component aborted: {:?}", error)})
-                                 },
-                                 None => {
-                                     if join.is_panic(){
-                                         Err(MadError::RunError { run: anyhow::anyhow!("component panicked: {}", join) })
-                                     } else {
-                                         Err(MadError::RunError { run: anyhow::anyhow!("component faced unknown error: {}", join) })
-                                     }
-                                 },
-                             }
-                         },
-                     };
-
-
-                        error_tx.send(CompletionResult { res , name: info.name  }).await
+                    res = comp.run(job_cancellation) => {
+                        error_tx.send(CompletionResult { res , name  }).await
                    }
                }
            });
@@ -563,7 +583,7 @@ impl Mad {
        tracing::debug!("closing components");

        for comp in &self.components {
-            tracing::trace!(component = %comp.info(), "mad closing");
+            tracing::trace!(component = &comp.name(), "mad closing");
            match comp.close().await {
                Ok(_) | Err(MadError::CloseNotDefined) => {}
                Err(e) => return Err(e),
@@ -581,46 +601,6 @@ async fn signal_unix_terminate() {
    sigterm.recv().await;
 }

-#[derive(Default, Clone)]
-pub struct ComponentInfo {
-    name: Option<String>,
-}
-
-impl Display for ComponentInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(
-            self.name
-                .as_ref()
-                .map(|n| n.as_str())
-                .unwrap_or_else(|| "unknown"),
-        )
-    }
-}
-
-impl ComponentInfo {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn with_name(&mut self, name: impl Into<String>) -> &mut Self {
-        self.name = Some(name.into());
-        self
-    }
-}
-
-impl From<String> for ComponentInfo {
-    fn from(value: String) -> Self {
-        Self { name: Some(value) }
-    }
-}
-impl From<&str> for ComponentInfo {
-    fn from(value: &str) -> Self {
-        Self {
-            name: Some(value.into()),
-        }
-    }
-}
-
 /// Trait for implementing MAD components.
 ///
 /// Components represent individual services or tasks that run as part
@@ -630,16 +610,18 @@ impl From<&str> for ComponentInfo {
 /// # Example
 ///
 /// ```rust
-/// use notmad::{Component, ComponentInfo, MadError};
+/// use notmad::{Component, MadError};
+/// use async_trait::async_trait;
 /// use tokio_util::sync::CancellationToken;
 ///
 /// struct DatabaseConnection {
 ///     url: String,
 /// }
 ///
+/// #[async_trait]
 /// impl Component for DatabaseConnection {
-///     fn info(&self) -> ComponentInfo {
-///         "database".into()
+///     fn name(&self) -> Option<String> {
+///         Some("database".to_string())
 ///     }
 ///
 ///     async fn setup(&self) -> Result<(), MadError> {
@@ -661,7 +643,8 @@ impl From<&str> for ComponentInfo {
 ///     }
 /// }
 /// ```
-pub trait Component: Send + Sync + 'static {
+#[async_trait::async_trait]
+pub trait Component {
    /// Returns an optional name for the component.
    ///
    /// This name is used in logging and error messages to identify
@@ -670,8 +653,8 @@ pub trait Component: Send + Sync + 'static {
    /// # Default
    ///
    /// Returns `None` if not overridden.
-    fn info(&self) -> ComponentInfo {
-        ComponentInfo::default()
+    fn name(&self) -> Option<String> {
+        None
    }

    /// Optional setup phase called before the component starts running.
@@ -689,8 +672,8 @@ pub trait Component: Send + Sync + 'static {
    ///
    /// If setup fails with an error other than `SetupNotDefined`,
    /// the entire application will stop before any components start running.
-    fn setup(&self) -> impl Future<Output = Result<(), MadError>> + Send + '_ {
-        async { Err(MadError::SetupNotDefined) }
+    async fn setup(&self) -> Result<(), MadError> {
+        Err(MadError::SetupNotDefined)
    }

    /// Main execution phase of the component.
@@ -712,10 +695,7 @@ pub trait Component: Send + Sync + 'static {
    /// # Errors
    ///
    /// Any error returned will trigger shutdown of all other components.
-    fn run(
-        &self,
-        cancellation_token: CancellationToken,
-    ) -> impl Future<Output = Result<(), MadError>> + Send + '_;
+    async fn run(&self, cancellation_token: CancellationToken) -> Result<(), MadError>;

    /// Optional cleanup phase called after the component stops.
    ///
@@ -732,73 +712,8 @@ pub trait Component: Send + Sync + 'static {
    ///
    /// Errors during close are logged but don't prevent other components
    /// from closing.
-    fn close(&self) -> impl Future<Output = Result<(), MadError>> + Send + '_ {
-        async { Err(MadError::CloseNotDefined) }
-    }
-}
-
-trait AsyncComponent: Send + Sync + 'static {
-    fn info_async(&self) -> ComponentInfo;
-
-    fn setup_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
-
-    fn run_async(
-        &self,
-        cancellation_token: CancellationToken,
-    ) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
-
-    fn close_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
-}
-
-impl<E: Component> AsyncComponent for E {
-    #[inline(always)]
-    fn info_async(&self) -> ComponentInfo {
-        self.info()
-    }
-
-    #[inline(always)]
-    fn setup_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
-        Box::pin(self.setup())
-    }
-
-    #[inline(always)]
-    fn run_async(
-        &self,
-        cancellation_token: CancellationToken,
-    ) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
-        Box::pin(self.run(cancellation_token))
-    }
-
-    #[inline(always)]
-    fn close_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
-        Box::pin(self.close())
-    }
-}
-
-#[derive(Clone)]
-pub struct SharedComponent {
-    component: Arc<dyn AsyncComponent + Send + Sync + 'static>,
-}
-
-impl SharedComponent {
-    #[inline(always)]
-    pub fn info(&self) -> ComponentInfo {
-        self.component.info_async()
-    }
-
-    #[inline(always)]
-    async fn setup(&self) -> Result<(), MadError> {
-        self.component.setup_async().await
-    }
-
-    #[inline(always)]
-    async fn run(&self, cancellation_token: CancellationToken) -> Result<(), MadError> {
-        self.component.run_async(cancellation_token).await
-    }
-
-    #[inline(always)]
    async fn close(&self) -> Result<(), MadError> {
-        self.component.close_async().await
+        Err(MadError::CloseNotDefined)
    }
 }

@@ -812,10 +727,12 @@ impl SharedComponent {
 ///
 /// ```rust
 /// use notmad::{Component, IntoComponent, Mad};
+/// # use async_trait::async_trait;
 /// # use tokio_util::sync::CancellationToken;
 ///
 /// struct MyService;
 ///
+/// # #[async_trait]
 /// # impl Component for MyService {
 /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
 /// # }
@@ -826,14 +743,12 @@ impl SharedComponent {
 /// ```
 pub trait IntoComponent {
    /// Converts self into an Arc-wrapped component.
-    fn into_component(self) -> SharedComponent;
+    fn into_component(self) -> Arc<dyn Component + Send + Sync + 'static>;
 }

-impl<T: Component> IntoComponent for T {
-    fn into_component(self) -> SharedComponent {
-        SharedComponent {
-            component: Arc::new(self),
-        }
+impl<T: Component + Send + Sync + 'static> IntoComponent for T {
+    fn into_component(self) -> Arc<dyn Component + Send + Sync + 'static> {
+        Arc::new(self)
    }
 }

@@ -857,6 +772,7 @@ where
    }
 }

+#[async_trait::async_trait]
 impl<F, Fut> Component for ClosureComponent<F, Fut>
 where
    F: Fn(CancellationToken) -> Fut + Send + Sync + 'static,
@@ -870,6 +786,7 @@ where
 #[cfg(test)]
 mod tests {
    use super::*;
+    use anyhow::Context;

    #[test]
    fn test_error_chaining_display() {
@@ -901,13 +818,13 @@ mod tests {
    fn test_aggregate_error_display() {
        let error1 = MadError::Inner(
            anyhow::anyhow!("database connection failed")
-                .context("failed to connect to PostgreSQL"),
+                .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"),
+                .context("web server initialization failed")
        );
        
        let aggregate = MadError::AggregateError(AggregateError {
@@ -947,7 +864,7 @@ mod tests {
        let error = MadError::Inner(
            anyhow::anyhow!("root cause")
                .context("middle layer")
-                .context("top layer"),
+                .context("top layer")
        );
        
        // Test that we can access the error chain
@@ -966,9 +883,10 @@ mod tests {
    async fn test_component_error_propagation() {
        struct FailingComponent;
        
+        #[async_trait::async_trait]
        impl Component for FailingComponent {
-            fn info(&self) -> ComponentInfo {
-                "test-component".into()
+            fn name(&self) -> Option<String> {
+                Some("test-component".to_string())
            }
            
            async fn run(&self, _cancel: CancellationToken) -> Result<(), MadError> {
--- a/crates/mad/src/waiter.rs
+++ b/crates/mad/src/waiter.rs
@@ -4,15 +4,19 @@
 //! without performing any work. Useful for keeping the application alive
 //! or as placeholders in conditional component loading.

+use std::sync::Arc;
+
+use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;

-use crate::{Component, ComponentInfo, IntoComponent, MadError, SharedComponent};
+use crate::{Component, MadError};

 /// A default waiter component that panics if run.
 ///
 /// This is used internally as a placeholder that should never
 /// actually be executed.
-pub struct DefaultWaiter;
+pub struct DefaultWaiter {}
+#[async_trait]
 impl Component for DefaultWaiter {
    async fn run(&self, _cancellation_token: CancellationToken) -> Result<(), MadError> {
        panic!("should never be called");
@@ -34,13 +38,13 @@ impl Component for DefaultWaiter {
 /// let waiter = Waiter::new(service.into_component());
 /// ```
 pub struct Waiter {
-    comp: SharedComponent,
+    comp: Arc<dyn Component + Send + Sync + 'static>,
 }

 impl Default for Waiter {
    fn default() -> Self {
        Self {
-            comp: DefaultWaiter {}.into_component(),
+            comp: Arc::new(DefaultWaiter {}),
        }
    }
 }
@@ -50,20 +54,21 @@ impl Waiter {
    ///
    /// The wrapped component's name will be used (prefixed with "waiter/"),
    /// but its run method will not be called.
-    pub fn new(c: SharedComponent) -> Self {
+    pub fn new(c: Arc<dyn Component + Send + Sync + 'static>) -> Self {
        Self { comp: c }
    }
 }

+#[async_trait]
 impl Component for Waiter {
    /// Returns the name of the waiter, prefixed with "waiter/".
    ///
    /// If the wrapped component has a name, it will be "waiter/{name}".
    /// Otherwise, returns "waiter".
-    fn info(&self) -> ComponentInfo {
-        match &self.comp.info().name {
-            Some(name) => format!("waiter/{name}").into(),
-            None => "waiter".into(),
+    fn name(&self) -> Option<String> {
+        match self.comp.name() {
+            Some(name) => Some(format!("waiter/{name}")),
+            None => Some("waiter".into()),
        }
    }

--- a/crates/mad/tests/mod.rs
+++ b/crates/mad/tests/mod.rs
@@ -1,6 +1,7 @@
 use std::sync::Arc;

-use notmad::{Component, ComponentInfo, Mad, MadError};
+use async_trait::async_trait;
+use notmad::{Component, Mad, MadError};
 use rand::Rng;
 use tokio::sync::Mutex;
 use tokio_util::sync::CancellationToken;
@@ -8,12 +9,13 @@ use tracing_test::traced_test;

 struct NeverEndingRun {}

+#[async_trait]
 impl Component for NeverEndingRun {
-    fn info(&self) -> ComponentInfo {
-        "NeverEndingRun".into()
+    fn name(&self) -> Option<String> {
+        Some("NeverEndingRun".into())
    }

-    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
        let millis_wait = rand::thread_rng().gen_range(50..1000);

        tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
@@ -136,30 +138,6 @@ async fn test_can_shutdown_gracefully() -> anyhow::Result<()> {
    Ok(())
 }

-#[tokio::test]
-#[traced_test]
-async fn test_component_panics_shutdowns_cleanly() -> anyhow::Result<()> {
-    let res = Mad::builder()
-        .add_fn({
-            move |_cancel| async move {
-                panic!("my inner panic");
-            }
-        })
-        .add_fn(|cancel| async move {
-            cancel.cancelled().await;
-
-            Ok(())
-        })
-        .run()
-        .await;
-
-    let err_content = res.unwrap_err().to_string();
-    assert!(err_content.contains("component panicked"));
-    assert!(err_content.contains("my inner panic"));
-
-    Ok(())
-}
-
 #[test]
 fn test_can_easily_transform_error() -> anyhow::Result<()> {
    fn fallible() -> anyhow::Result<()> {