feat(logging): use dynamic node ids for spans

Author: RolandSherwin

ant-logging/src/layers.rs

@@ -330,6 +330,43 @@ fn get_log_level_from_str(log_level: &str) -> Result<Level> {
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use tracing_appender::non_blocking::NonBlocking;
+use tracing::field::{Field, Visit};
+use tracing::span::{Attributes, Id};
+
+/// Metadata stored with each node span for routing purposes
+#[derive(Debug)]
+struct NodeMetadata {
+    node_name: String,
+}
+
+/// Visitor to extract node_id field from span attributes
+struct NodeIdVisitor {
+    node_id: Option<usize>,
+}
+
+impl Visit for NodeIdVisitor {
+    fn record_u64(&mut self, field: &Field, value: u64) {
+        if field.name() == "node_id" {
+            self.node_id = Some(value as usize);
+        }
+    }
+
+    fn record_i64(&mut self, field: &Field, value: i64) {
+        if field.name() == "node_id" {
+            self.node_id = Some(value as usize);
+        }
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+        if field.name() == "node_id" {
+            // Try to extract from debug representation as fallback
+            let debug_str = format!("{value:?}");
+            if let Ok(parsed) = debug_str.parse::<usize>() {
+                self.node_id = Some(parsed);
+            }
+        }
+    }
+}
 
 /// Layer that routes events to different file appenders based on span context
 pub struct NodeRoutingLayer {
@@ -363,6 +400,22 @@ where
         Filter::enabled(&self.targets_filter, meta, &ctx)
     }
 
+    fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
+        let span = ctx.span(id).expect("Span should exist in registry");
+        let span_name = span.name();
+
+        // Extract node_id from spans named "node"
+        if span_name == "node" {
+            let mut visitor = NodeIdVisitor { node_id: None };
+            attrs.record(&mut visitor);
+
+            if let Some(node_id) = visitor.node_id {
+                let node_name = format!("node_{node_id}");
+                span.extensions_mut().insert(NodeMetadata { node_name });
+            }
+        }
+    }
+
     fn on_event(&self, event: &tracing::Event<'_>, ctx: Context<'_, S>) {
         // Find which node this event belongs to based on span hierarchy
         let mut target_node = None;
@@ -372,7 +425,15 @@ where
             while let Some(span) = current {
                 let span_name = span.name();
 
-                // Check for standard node spans: node_1, node_2, etc.
+                // Check for dynamic node spans with stored metadata
+                if span_name == "node" {
+                    if let Some(metadata) = span.extensions().get::<NodeMetadata>() {
+                        target_node = Some(metadata.node_name.clone());
+                        break;
+                    }
+                }
+
+                // Check for legacy node spans: node_1, node_2, etc. (backwards compatibility)
                 if span_name.starts_with("node_") {
                     target_node = Some(span_name.to_string());
                     break;

ant-logging/tests/multi_node_logging.rs

@@ -22,8 +22,8 @@ async fn test_multi_node_logging_e2e() {
         .initialize_with_multi_node_logging(2)
         .expect("Failed to initialize multi-node logging");
 
-    // Log messages from different nodes
-    let node_1_span = tracing::info_span!("node_1");
+    // Log messages from different nodes using new dynamic span format
+    let node_1_span = tracing::info_span!("node", node_id = 1);
     let task1 = async {
         info!("Message from node 1");
         info!("Another message from node 1");
@@ -38,7 +38,7 @@ async fn test_multi_node_logging_e2e() {
     }
     .instrument(node_1_span);
 
-    let node_2_span = tracing::info_span!("node_2");
+    let node_2_span = tracing::info_span!("node", node_id = 2);
     let task2 = async {
         info!("Message from node 2");
     }
@@ -63,6 +63,9 @@ async fn test_multi_node_logging_e2e() {
     let node_1_content = read_log_content(&node_1_dir).expect("Failed to read node 1 logs");
     let node_2_content = read_log_content(&node_2_dir).expect("Failed to read node 2 logs");
 
+    println!("Node 1 logs:\n{}", node_1_content);
+    println!("Node 2 logs:\n{}", node_2_content);
+
     // Check node 1 logs contain all its messages
     assert!(
         node_1_content.contains("Message from node 1"),
@@ -97,18 +100,37 @@ async fn test_multi_node_logging_e2e() {
         "Should contain target name"
     );
     assert!(
-        node_1_content.contains("node_1"),
-        "Should contain span information"
+        node_1_content.contains("/node"),
+        "Should contain span information with /node"
     );
     assert!(
-        node_2_content.contains("node_2"),
-        "Should contain span information"
+        node_2_content.contains("/node"),
+        "Should contain span information with /node"
     );
 
     println!("Node 1 logs:\n{}", node_1_content);
     println!("Node 2 logs:\n{}", node_2_content);
 }
 
+#[test]
+fn test_unlimited_node_span_creation() {
+    // Test that we can create spans for nodes beyond the old 20-node limit
+    // This tests the span creation functionality without requiring a full logging setup
+    
+    let test_nodes = vec![1, 15, 21, 25, 50, 100];
+    
+    for &node_id in &test_nodes {
+        // This should work for any node_id now (no hardcoded limit)
+        let node_span = tracing::info_span!("node", node_id = node_id);
+        
+        // Verify the span can be entered and used
+        let _enter = node_span.enter();
+        // If we get here without panicking, the span creation works
+    }
+    
+    println!("Successfully created spans for node IDs: {:?}", test_nodes);
+}
+
 /// Helper function to read log content from a node directory
 fn read_log_content(node_dir: &PathBuf) -> Result<String, Box<dyn std::error::Error>> {
     let mut content = String::new();

ant-node/src/spawn/network_spawner.rs

@@ -14,73 +14,11 @@ use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::path::PathBuf;
 use tracing::Instrument;
 
-/// Macro to create node spans in a clean way.
-/// This handles the limitation that tracing span names must be compile-time constants
-/// while still providing a clean interface for node IDs up to 20 nodes.
-macro_rules! create_node_span {
-    (1) => {
-        tracing::info_span!("node_1")
-    };
-    (2) => {
-        tracing::info_span!("node_2")
-    };
-    (3) => {
-        tracing::info_span!("node_3")
-    };
-    (4) => {
-        tracing::info_span!("node_4")
-    };
-    (5) => {
-        tracing::info_span!("node_5")
-    };
-    (6) => {
-        tracing::info_span!("node_6")
-    };
-    (7) => {
-        tracing::info_span!("node_7")
-    };
-    (8) => {
-        tracing::info_span!("node_8")
-    };
-    (9) => {
-        tracing::info_span!("node_9")
-    };
-    (10) => {
-        tracing::info_span!("node_10")
-    };
-    (11) => {
-        tracing::info_span!("node_11")
-    };
-    (12) => {
-        tracing::info_span!("node_12")
-    };
-    (13) => {
-        tracing::info_span!("node_13")
-    };
-    (14) => {
-        tracing::info_span!("node_14")
-    };
-    (15) => {
-        tracing::info_span!("node_15")
-    };
-    (16) => {
-        tracing::info_span!("node_16")
-    };
-    (17) => {
-        tracing::info_span!("node_17")
-    };
-    (18) => {
-        tracing::info_span!("node_18")
-    };
-    (19) => {
-        tracing::info_span!("node_19")
-    };
-    (20) => {
-        tracing::info_span!("node_20")
-    };
-    ($id:expr) => {
-        tracing::info_span!("node_other", node_id = $id)
-    };
+/// Create a node span with unlimited node ID support.
+/// Uses a static span name "node" with the node_id as a field to work around
+/// the tracing library's requirement for compile-time span names.
+fn create_node_span(node_id: usize) -> tracing::Span {
+    tracing::info_span!("node", node_id = node_id)
 }
 
 pub struct NetworkSpawner {
@@ -251,8 +189,7 @@ async fn spawn_network(
     for i in 0..size {
         let node_id = i + 1;
         // Create a span with a unique name for this specific node
-        // Since tracing requires compile-time span names, we use a cleaner macro approach
-        let node_span = create_node_span!(node_id);
+        let node_span = create_node_span(node_id);
 
         // Instrument the entire node spawn with the node_id span
         let spawn_future = async {