Enhance error handling and logging in engine examples and documentation

README.md

@@ -91,6 +91,7 @@ Action handlers that effect changes:
 use botcore::engine::Engine;
 use botcore::types::{Collector, Strategy, Executor};
 use botcore::Result;
+use tracing::{error, info};
 
 // 1. Define your types
 #[derive(Debug, Clone)]
@@ -139,8 +140,23 @@ async fn main() -> Result<()> {
     engine.add_strategy(Box::new(MyStrategy));
     engine.add_executor(Box::new(MyExecutor));
 
-    let join_set = engine.run().await?;
-    join_set.await;
+    match engine.run().await {
+        Ok(mut set) => {
+            while let Some(res) = set.join_next().await {
+                match res {
+                    Ok(res) => {
+                        info!("res: {:?}", res);
+                    }
+                    Err(e) => {
+                        info!("error: {:?}", e);
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            error!("Engine run error: {:?}", e);
+        }
+    }
     Ok(())
 }
 ```
@@ -176,7 +192,6 @@ The engine can be configured through builder methods:
 let engine = Engine::new()
     .with_event_channel_capacity(1024)
     .with_action_channel_capacity(1024)
-    .with_metrics_enabled(true);
 ```
 
 ## Error Handling

examples/block_trader.rs

@@ -16,6 +16,7 @@ use botcore::types::{Collector, CollectorStream, Executor, Strategy};
 use botcore::Result;
 use std::time::Duration;
 use tokio::time;
+use tracing::{error, info};
 
 /// A simple event containing block information
 #[derive(Debug, Clone)]
@@ -132,7 +133,23 @@ async fn main() -> Result<()> {
     engine.add_executor(Box::new(TradeExecutor));
 
     // Run the engine
-    let _join_set = engine.run().await?;
+    match engine.run().await {
+        Ok(mut set) => {
+            while let Some(res) = set.join_next().await {
+                match res {
+                    Ok(res) => {
+                        info!("res: {:?}", res);
+                    }
+                    Err(e) => {
+                        info!("error: {:?}", e);
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            error!("Engine run error: {:?}", e);
+        }
+    }
 
     // Keep the engine running for a while
     time::sleep(Duration::from_secs(30)).await;

src/engine.rs

@@ -28,6 +28,7 @@ use crate::metrics::METRICS;
 /// use botcore::types::{Collector, CollectorStream, Strategy, Executor};
 /// use async_trait::async_trait;
 /// use tokio_stream;
+/// use tracing::{info, error};
 /// 
 /// #[derive(Debug, Clone)]
 /// struct BlockEvent;
@@ -82,12 +83,22 @@ use crate::metrics::METRICS;
 ///     engine.add_strategy(Box::new(TradingStrategy));
 ///     engine.add_executor(Box::new(TradeExecutor));
 ///     
-///     // Run the engine
-///     let mut join_set = engine.run().await?;
-///     
-///     // Wait for all tasks to complete
-///     while join_set.join_next().await.is_some() {}
-///     Ok(())
+///     // Run the engine and handle task results
+///     match engine.run().await {
+///         Ok(mut set) => {
+///             while let Some(res) = set.join_next().await {
+///                 match res {
+///                     Ok(res) => info!("Task completed: {:?}", res),
+///                     Err(e) => info!("Task error: {:?}", e),
+///                 }
+///             }
+///             Ok(())
+///         }
+///         Err(e) => {
+///             error!("Engine run error: {:?}", e);
+///             Err(e)
+///         }
+///     }
 /// }
 /// ```
 pub struct Engine<E, A> {