Merge branch 'main' into Robo210-patch-1

Robo210 · web-flow · commit 887be87433e4 · 2026-02-25T14:50:54.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,6 +14,9 @@ crate-type = ["rlib"]
 
 [features]
 global_filter = []
+# Enable OpenTelemetry trace context extraction. When enabled, span_id and trace_id
+# will be extracted from tracing-opentelemetry's OtelData span extensions when available.
+opentelemetry = ["dep:tracing-opentelemetry", "dep:opentelemetry"]
 
 [dependencies]
 tracing = {version = "0.1", default-features = false}
@@ -25,6 +28,10 @@ thiserror = {version="2", default-features = false}
 hashers = "1"
 hashbrown = "0.15"
 
+# Optional OpenTelemetry dependencies
+tracing-opentelemetry = {version = "0.32", optional = true}
+opentelemetry = {version = "0.31", optional = true, default-features = false, features = ["trace"]}
+
 [target.'cfg(not(target_os = "linux"))'.dependencies]
 tracelogging = ">= 1.2.0"
 tracelogging_dynamic = ">= 1.2.0"
diff --git a/benches/etw.rs b/benches/etw.rs
@@ -127,9 +127,7 @@ pub fn etw_benchmark(c: &mut Criterion) {
                     name: "evtname",
                     Level::INFO,
                     1,
-                    field1 = 1,
-                    field2 = "asdf",
-                    field3 = 1.1,
+                    { field1 = 1, field2 = "asdf", field3 = 1.1 },
                     "Enabled event!"
                 );
             })
diff --git a/src/layer/layer_impl.rs b/src/layer/layer_impl.rs
@@ -121,6 +121,20 @@ where
             .event_span(event)
             .map_or(0, |evt| evt.parent().map_or(0, |p| p.id().into_u64()));
 
+        // Extract OpenTelemetry context if available
+        #[cfg(feature = "opentelemetry")]
+        let otel_context = ctx.event_span(event).and_then(|span| {
+            let otel_ctx = crate::otel::extract_otel_context(&span);
+            if otel_ctx.is_valid {
+                Some((otel_ctx.trace_id, otel_ctx.span_id))
+            } else {
+                None
+            }
+        });
+
+        #[cfg(not(feature = "opentelemetry"))]
+        let otel_context: Option<([u8; 32], [u8; 16])> = None;
+
         let etw_meta = get_event_metadata(&event.metadata().callsite());
         let (name, keyword, tag) = if let Some(meta) = etw_meta {
             (event.metadata().name(), meta.kw, meta.event_tag)
@@ -137,6 +151,7 @@ where
             keyword,
             tag,
             event,
+            otel_context,
         );
     }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -108,11 +108,11 @@
 //! to consumers asynchronously per the platform design.
 //!
 //! ### Heap Allocations
-//! 
+//!
 //! The goal of this crate is to have no heap allocations in the hot path (when an event is logged).
 //! Currently there are a few circumstances when logging an event requires a heap
 //! allocation, outlined below.
-//! 
+//!
 //! Total memory usage by this crate will vary based on workload, but will usually
 //! stay in the 10s or low 100s of kilobytes, and should remain stable once the
 //! first event has been logged.
@@ -122,14 +122,14 @@
 //!
 //! - Logging events with the [Debug][std::fmt::Debug] format specifier (`:?`) will
 //! necessitate a heap allocation to format the value into a string.
-//! 
+//!
 //! <div class="warning">
-//! 
+//!
 //! All event messages (the format strings to the event) are, for reasons
 //! outside of the control of this crate, formatted as debug formats rather than as
 //! a string. This effectively means every single event is forced to perform at least
 //! one heap allocation. In benchmarking, this does not seem to be a major performance issue.
-//! 
+//!
 //! </div>
 //!
 //! - Logging strings copies them to the heap first. This is a side-effect of how
@@ -195,6 +195,11 @@ mod values;
 pub mod _details;
 pub mod error;
 
+// OpenTelemetry integration module - only available with the "opentelemetry" feature
+#[cfg(feature = "opentelemetry")]
+#[cfg_attr(docsrs, doc(cfg(feature = "opentelemetry")))]
+pub(crate) mod otel;
+
 pub use layer_builder::LayerBuilder;
 
 mod layer;
@@ -361,6 +366,17 @@ macro_rules! etw_event {
     (name: $name:expr, $lvl:expr, $kw:expr, $($k:ident).+) => (
         $crate::etw_event!(name: $name, $lvl, $kw, 0, $($k).+,)
     );
+    // Handle bare message string: etw_event!(name: "Name", Level::INFO, 1, "message")
+    (name: $name:expr, $lvl:expr, $kw:expr, $msg:literal) => (
+        $crate::etw_event!(
+            target: module_path!(),
+            name: $name,
+            $lvl,
+            $kw,
+            0,
+            { message = $msg }
+        )
+    );
     (name: $name:expr, $lvl:expr, $kw:expr, $($arg:tt)+ ) => (
         $crate::etw_event!(target: module_path!(), name: $name, $lvl, $kw, 0, { $($arg)+ })
     );
diff --git a/src/native/etw.rs b/src/native/etw.rs
@@ -5,9 +5,7 @@ use crate::{
     values::{event_values::*, *},
 };
 use chrono::{Datelike, Timelike};
-use std::io::{Cursor, Write};
 use std::marker::PhantomData;
-use std::mem::MaybeUninit;
 use std::{cell::RefCell, ops::DerefMut, pin::Pin, sync::Arc, time::SystemTime};
 use tracelogging::*;
 use tracelogging_dynamic::EventBuilder;
@@ -299,6 +297,7 @@ impl<Mode: OutputMode> super::EventWriter<NormalOutput> for Provider<Mode> {
         keyword: u64,
         event_tag: u32,
         event: &tracing::Event<'_>,
+        _otel_context: Option<([u8; 32], [u8; 16])>,
     ) {
         let mut activity_id: [u8; 16] = *GLOBAL_ACTIVITY_SEED;
         activity_id[0] = if current_span != 0 {
@@ -414,11 +413,33 @@ impl<Mode: OutputMode> super::EventWriter<CommonSchemaOutput> for Provider<Mode>
     {
         let span_name = span.name();
 
-        let span_id = unsafe {
-            let mut span_id = MaybeUninit::<[u8; 16]>::uninit();
-            let mut cur = Cursor::new((*span_id.as_mut_ptr()).as_mut_slice());
-            write!(&mut cur, "{:16x}", span.id().into_u64()).expect("!write");
-            span_id.assume_init()
+        // Extract trace_id and span_id - prefer OpenTelemetry context when available
+        #[cfg(feature = "opentelemetry")]
+        let (trace_id, span_id) = {
+            let otel_ctx = crate::otel::extract_otel_context(span);
+            if otel_ctx.is_valid {
+                (otel_ctx.trace_id, otel_ctx.span_id)
+            } else {
+                // Fall back to local tracing span ID
+                let mut span_id_buf = [0u8; 16];
+                let trace_id_buf = [0u8; 32];
+                let _ = std::io::Write::write_fmt(
+                    &mut span_id_buf.as_mut_slice(),
+                    format_args!("{:016x}", span.id().into_u64()),
+                );
+                (trace_id_buf, span_id_buf)
+            }
+        };
+
+        #[cfg(not(feature = "opentelemetry"))]
+        let (trace_id, span_id) = {
+            let mut span_id_buf = [0u8; 16];
+            let trace_id_buf = [0u8; 32];
+            let _ = std::io::Write::write_fmt(
+                &mut span_id_buf.as_mut_slice(),
+                format_args!("{:016x}", span.id().into_u64()),
+            );
+            (trace_id_buf, span_id_buf)
         };
 
         EBW.with(|eb| {
@@ -441,7 +462,7 @@ impl<Mode: OutputMode> super::EventWriter<CommonSchemaOutput> for Provider<Mode>
 
                 eb.add_struct("ext_dt", 2, 0);
                 {
-                    eb.add_str8("traceId", "", OutType::Utf8, 0); // TODO
+                    eb.add_str8("traceId", trace_id, OutType::Utf8, 0);
                     eb.add_str8("spanId", span_id, OutType::Utf8, 0);
                 }
             }
@@ -465,11 +486,30 @@ impl<Mode: OutputMode> super::EventWriter<CommonSchemaOutput> for Provider<Mode>
                 eb.add_str8("_typeName", "Span", OutType::Utf8, 0);
 
                 if let Some(parent) = span_parent {
-                    let parent_span_id = unsafe {
-                        let mut span_id = MaybeUninit::<[u8; 16]>::uninit();
-                        let mut cur = Cursor::new((*span_id.as_mut_ptr()).as_mut_slice());
-                        write!(&mut cur, "{:16x}", parent.id().into_u64()).expect("!write");
-                        span_id.assume_init()
+                    // Extract parent span_id - prefer OpenTelemetry context when available
+                    #[cfg(feature = "opentelemetry")]
+                    let parent_span_id = {
+                        let otel_ctx = crate::otel::extract_otel_context(&parent);
+                        if otel_ctx.is_valid {
+                            otel_ctx.span_id
+                        } else {
+                            let mut buf = [0u8; 16];
+                            let _ = std::io::Write::write_fmt(
+                                &mut buf.as_mut_slice(),
+                                format_args!("{:016x}", parent.id().into_u64()),
+                            );
+                            buf
+                        }
+                    };
+
+                    #[cfg(not(feature = "opentelemetry"))]
+                    let parent_span_id = {
+                        let mut buf = [0u8; 16];
+                        let _ = std::io::Write::write_fmt(
+                            &mut buf.as_mut_slice(),
+                            format_args!("{:016x}", parent.id().into_u64()),
+                        );
+                        buf
                     };
 
                     eb.add_str8("parentId", parent_span_id, OutType::Utf8, 0);
@@ -518,6 +558,7 @@ impl<Mode: OutputMode> super::EventWriter<CommonSchemaOutput> for Provider<Mode>
         keyword: u64,
         event_tag: u32,
         event: &tracing::Event<'_>,
+        otel_context: Option<([u8; 32], [u8; 16])>,
     ) {
         EBW.with(|eb| {
             let mut eb = eb.borrow_mut();
@@ -532,27 +573,33 @@ impl<Mode: OutputMode> super::EventWriter<CommonSchemaOutput> for Provider<Mode>
             eb.add_u16("__csver__", 0x0401, OutType::Signed, 0);
             eb.add_struct(
                 "PartA",
-                1 + if current_span != 0 { 1 } else { 0 }, /* + exts.len() as u8*/
+                1 + if current_span != 0 || otel_context.is_some() { 1 } else { 0 }, /* + exts.len() as u8*/
                 0,
             );
             {
                 let time: String =
                     chrono::DateTime::to_rfc3339(&chrono::DateTime::<chrono::Utc>::from(timestamp));
                 eb.add_str8("time", time, OutType::Utf8, 0);
 
-                if current_span != 0 {
+                // Use OTel context if available, otherwise fall back to local span ID
+                if let Some((trace_id, span_id)) = otel_context {
                     eb.add_struct("ext_dt", 2, 0);
                     {
-                        let span_id = unsafe {
-                            let mut span_id = MaybeUninit::<[u8; 16]>::uninit();
-                            let mut cur = Cursor::new((*span_id.as_mut_ptr()).as_mut_slice());
-                            write!(&mut cur, "{:16x}", current_span).expect("!write");
-                            span_id.assume_init()
-                        };
-
-                        eb.add_str8("traceId", "", OutType::Utf8, 0); // TODO
+                        eb.add_str8("traceId", trace_id, OutType::Utf8, 0);
                         eb.add_str8("spanId", span_id, OutType::Utf8, 0);
                     }
+                } else if current_span != 0 {
+                    eb.add_struct("ext_dt", 2, 0);
+                    {
+                        let mut span_id_buf = [0u8; 16];
+                        let _ = std::io::Write::write_fmt(
+                            &mut span_id_buf.as_mut_slice(),
+                            format_args!("{:016x}", current_span),
+                        );
+
+                        eb.add_str8("traceId", [0u8; 32], OutType::Utf8, 0);
+                        eb.add_str8("spanId", span_id_buf, OutType::Utf8, 0);
+                    }
                 }
             }
 
diff --git a/src/native/mod.rs b/src/native/mod.rs
@@ -170,5 +170,6 @@ pub trait EventWriter<OutMode: OutputMode> {
         keyword: u64,
         event_tag: u32,
         event: &tracing::Event<'_>,
+        otel_context: Option<([u8; 32], [u8; 16])>, // (trace_id, span_id) when opentelemetry feature is enabled
     );
 }
diff --git a/src/native/noop.rs b/src/native/noop.rs
@@ -86,6 +86,7 @@ impl<OutMode: OutputMode> crate::native::EventWriter<OutMode> for Provider<OutMo
         _keyword: u64,
         _event_tag: u32,
         _event: &tracing::Event<'_>,
+        _otel_context: Option<([u8; 32], [u8; 16])>,
     ) {
     }
 }
diff --git a/src/native/user_events.rs b/src/native/user_events.rs
diff --git a/src/otel.rs b/src/otel.rs

Original file line number	Diff line number	Diff line change
`@@ -170,5 +170,6 @@ pub trait EventWriter<OutMode: OutputMode> {`
`170`	`170`	`keyword: u64,`
`171`	`171`	`event_tag: u32,`
`172`	`172`	`event: &tracing::Event<'_>,`
	`173`	`+ otel_context: Option<([u8; 32], [u8; 16])>, // (trace_id, span_id) when opentelemetry feature is enabled`
`173`	`174`	`);`
`174`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,7 @@ impl<OutMode: OutputMode> crate::native::EventWriter<OutMode> for Provider<OutMo`
`86`	`86`	`_keyword: u64,`
`87`	`87`	`_event_tag: u32,`
`88`	`88`	`_event: &tracing::Event<'_>,`
	`89`	`+ _otel_context: Option<([u8; 32], [u8; 16])>,`
`89`	`90`	`) {`
`90`	`91`	`}`
`91`	`92`	`}`