[trace] add 'trace' feature to guest tracing crates

dblnz · dblnz · commit bf41dc099985 · 2025-07-31T18:21:47.000+03:00
- This allows the use of the 'hyperlight-guest-tracing'
  without having the tracing enabled
- Now the user can select at compile time whether the
  macros enable tracing or not
- Before this change, the crate using the macros from
  hyperlight-guest-tracing-macro needed to define a features
  called 'trace_guest' because the generated code would gate
  everything with that feature
- The change makes the generation of code dependent on the
 'trace' feature
- Some of the variables used in the macros were prefixed with
  an '_' to avoid warnings when the 'trace' feature is not set

Signed-off-by: Doru Blânzeanu &lt;dblnz@pm.me&gt;
diff --git a/src/hyperlight_guest/Cargo.toml b/src/hyperlight_guest/Cargo.toml
@@ -15,8 +15,8 @@ Provides only the essential building blocks for interacting with the host enviro
 anyhow = { version = "1.0.98", default-features = false }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 hyperlight-common = { workspace = true }
-hyperlight-guest-tracing = { workspace = true }
+hyperlight-guest-tracing = { workspace = true, default-features = false }
 
 [features]
 default = []
-trace_guest = []
+trace_guest = ["hyperlight-guest-tracing/trace"]
diff --git a/src/hyperlight_guest_bin/Cargo.toml b/src/hyperlight_guest_bin/Cargo.toml
@@ -17,13 +17,13 @@ and third-party code used by our C-API needed to build a native hyperlight-guest
 default = ["libc", "printf"]
 libc = [] # compile musl libc
 printf = [ "libc" ] # compile printf
-trace_guest = ["hyperlight-common/trace_guest", "hyperlight-guest/trace_guest"]
+trace_guest = ["hyperlight-common/trace_guest", "hyperlight-guest/trace_guest", "hyperlight-guest-tracing/trace"]
 mem_profile = ["hyperlight-common/unwind_guest","hyperlight-common/mem_profile"]
 
 [dependencies]
 hyperlight-guest = { workspace = true, default-features = false }
 hyperlight-common = { workspace = true, default-features = false }
-hyperlight-guest-tracing = { workspace = true }
+hyperlight-guest-tracing = { workspace = true, default-features = false }
 buddy_system_allocator = "0.11.0"
 log = { version = "0.4", default-features = false }
 spin = "0.10.0"
diff --git a/src/hyperlight_guest_tracing/Cargo.toml b/src/hyperlight_guest_tracing/Cargo.toml
@@ -10,9 +10,13 @@ readme.workspace = true
 description = """Provides the tracing functionality for the hyperlight guest."""
 
 [dependencies]
-hyperlight-common = { workspace = true, default-features = false, features = ["trace_guest"] }
-hyperlight-guest-tracing-macro = { workspace = true }
+hyperlight-common = { workspace = true, default-features = false }
+hyperlight-guest-tracing-macro = { workspace = true, default-features = false }
 spin = "0.10.0"
 
 [lints]
 workspace = true
+
+[features]
+default = ["trace"]
+trace = [ "hyperlight-guest-tracing-macro/trace", "hyperlight-common/trace_guest" ]
diff --git a/src/hyperlight_guest_tracing/src/lib.rs b/src/hyperlight_guest_tracing/src/lib.rs
@@ -18,6 +18,7 @@ limitations under the License.
 /// Re-export the tracing macros
 /// This allows users to use the macros without needing to import them explicitly.
 pub use hyperlight_guest_tracing_macro::*;
+#[cfg(feature = "trace")]
 pub use trace::{create_trace_record, flush_trace_buffer};
 
 /// Maximum length of a trace message in bytes.
@@ -68,6 +69,7 @@ pub mod invariant_tsc {
     }
 }
 
+#[cfg(feature = "trace")]
 mod trace {
     // === Dependencies ===
     extern crate alloc;
diff --git a/src/hyperlight_guest_tracing_macro/Cargo.toml b/src/hyperlight_guest_tracing_macro/Cargo.toml
@@ -15,7 +15,8 @@ quote = "1.0.40"
 syn = { version = "2.0.104", features = ["full"] }
 
 [features]
-default = []
+default = ["trace"]
+trace = []
 
 [lib]
 proc-macro = true
diff --git a/src/hyperlight_guest_tracing_macro/src/lib.rs b/src/hyperlight_guest_tracing_macro/src/lib.rs
@@ -27,8 +27,7 @@ use syn::{ItemFn, parse_macro_input};
 /// }
 /// ```
 ///
-/// This macro will create a trace record when the function is called, if the `trace_guest`
-/// feature is enabled.
+/// This macro will create a trace record when the function is called
 ///
 /// The trace record will contain the function name as a string.
 /// Note: This macro is intended to be used with the `hyperlight_guest_tracing` crate.
@@ -45,47 +44,57 @@ pub fn trace_function(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let fn_output = &input_fn.sig.output;
 
     // Compose entry/exit messages
-    let entry_msg = format!("> {}", fn_name_str);
-    let exit_msg = format!("< {}", fn_name_str);
+    let _entry_msg = format!("> {}", fn_name_str);
+    let _exit_msg = format!("< {}", fn_name_str);
 
     let expanded = match fn_output {
         syn::ReturnType::Default => {
             // No return value (unit)
+            #[cfg(feature = "trace")]
             quote! {
                 #(#fn_attrs)*
                 #fn_vis #fn_sig {
-                    #[cfg(feature = "trace_guest")]
                     const _: () = assert!(
-                        #entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
+                        #_entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
                         "Trace message exceeds the maximum bytes length",
                     );
-                    #[cfg(feature = "trace_guest")]
-                    ::hyperlight_guest_tracing::create_trace_record(#entry_msg);
+                    ::hyperlight_guest_tracing::create_trace_record(#_entry_msg);
                     // Call the original function body
                     #fn_block
-                    #[cfg(feature = "trace_guest")]
-                    ::hyperlight_guest_tracing::create_trace_record(#exit_msg);
+                    ::hyperlight_guest_tracing::create_trace_record(#_exit_msg);
+                }
+            }
+            #[cfg(not(feature = "trace"))]
+            quote! {
+                #(#fn_attrs)*
+                #fn_vis #fn_sig {
+                    #fn_block
                 }
             }
         }
         syn::ReturnType::Type(_, _) => {
             // Has a return value
+            #[cfg(feature = "trace")]
             quote! {
                 #(#fn_attrs)*
                 #fn_vis #fn_sig {
-                    #[cfg(feature = "trace_guest")]
                     const _: () = assert!(
-                        #entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
+                        #_entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
                         "Trace message exceeds the maximum bytes length",
                     );
-                    #[cfg(feature = "trace_guest")]
-                    ::hyperlight_guest_tracing::create_trace_record(#entry_msg);
+                    ::hyperlight_guest_tracing::create_trace_record(#_entry_msg);
                     let __trace_result = (|| #fn_block )();
-                    #[cfg(feature = "trace_guest")]
-                    ::hyperlight_guest_tracing::create_trace_record(#exit_msg);
+                    ::hyperlight_guest_tracing::create_trace_record(#_exit_msg);
                     __trace_result
                 }
             }
+            #[cfg(not(feature = "trace"))]
+            quote! {
+                #(#fn_attrs)*
+                #fn_vis #fn_sig {
+                    #fn_block
+                }
+            }
         }
     };
 
@@ -202,36 +211,41 @@ pub fn trace(input: TokenStream) -> TokenStream {
         _ => unreachable!(),
     };
     if let Some(statement) = parsed.statement {
-        let entry_msg = format!("+ {}", trace_message);
-        let exit_msg = format!("- {}", trace_message);
+        let _entry_msg = format!("+ {}", trace_message);
+        let _exit_msg = format!("- {}", trace_message);
+        #[cfg(feature = "trace")]
         let expanded = quote! {
             {
-                #[cfg(feature = "trace_guest")]
                 const _: () = assert!(
-                    #entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
+                    #_entry_msg.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
                     "Trace message exceeds the maximum bytes length",
                 );
-                #[cfg(feature = "trace_guest")]
-                ::hyperlight_guest_tracing::create_trace_record(#entry_msg);
+                ::hyperlight_guest_tracing::create_trace_record(#_entry_msg);
                 let __trace_result = #statement;
-                #[cfg(feature = "trace_guest")]
-                ::hyperlight_guest_tracing::create_trace_record(#exit_msg);
+                ::hyperlight_guest_tracing::create_trace_record(#_exit_msg);
                 __trace_result
             }
         };
+        #[cfg(not(feature = "trace"))]
+        let expanded = quote! {
+            #statement
+        };
+
         TokenStream::from(expanded)
     } else {
+        #[cfg(feature = "trace")]
         let expanded = quote! {
             {
-                #[cfg(feature = "trace_guest")]
                 const _: () = assert!(
                     #trace_message.len() <= hyperlight_guest_tracing::MAX_TRACE_MSG_LEN,
                     "Trace message exceeds the maximum bytes length",
                 );
-                #[cfg(feature = "trace_guest")]
                 ::hyperlight_guest_tracing::create_trace_record(#trace_message);
             }
         };
+        #[cfg(not(feature = "trace"))]
+        let expanded = quote! {};
+
         TokenStream::from(expanded)
     }
 }
@@ -244,12 +258,14 @@ pub fn trace(input: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro]
 pub fn flush(_input: TokenStream) -> TokenStream {
+    #[cfg(feature = "trace")]
     let expanded = quote! {
         {
-            #[cfg(feature = "trace_guest")]
             ::hyperlight_guest_tracing::flush_trace_buffer();
         }
     };
+    #[cfg(not(feature = "trace"))]
+    let expanded = quote! {};
 
     TokenStream::from(expanded)
 }
diff --git a/src/hyperlight_host/Cargo.toml b/src/hyperlight_host/Cargo.toml
@@ -132,7 +132,7 @@ executable_heap = []
 print_debug = []
 # Dumps the VM state to a file on unexpected errors or crashes. The path of the file will be printed on stdout and logged.
 crashdump = ["dep:chrono"]
-trace_guest = ["hyperlight-common/trace_guest", "dep:hyperlight-guest-tracing"]
+trace_guest = ["hyperlight-common/trace_guest", "hyperlight-guest-tracing/trace"]
 # This feature enables unwinding the guest stack from the host, in
 # order to produce stack traces for debugging or profiling.
 unwind_guest = [ "trace_guest", "dep:framehop", "dep:fallible-iterator", "hyperlight-common/unwind_guest" ]

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ limitations under the License.`
`18`	`18`	`/// Re-export the tracing macros`
`19`	`19`	`/// This allows users to use the macros without needing to import them explicitly.`
`20`	`20`	`pub use hyperlight_guest_tracing_macro::*;`
	`21`	`+#[cfg(feature = "trace")]`
`21`	`22`	`pub use trace::{create_trace_record, flush_trace_buffer};`
`22`	`23`
`23`	`24`	`/// Maximum length of a trace message in bytes.`
`@@ -68,6 +69,7 @@ pub mod invariant_tsc {`
`68`	`69`	`}`
`69`	`70`	`}`
`70`	`71`
	`72`	`+#[cfg(feature = "trace")]`
`71`	`73`	`mod trace {`
`72`	`74`	`// === Dependencies ===`
`73`	`75`	`extern crate alloc;`