|
| 1 | +//! Construct [`tracing_core::Metadata`] objects in the way required by that ecosystem. |
| 2 | +//! |
| 3 | +//! Dynamic call site stuff based on <https://github.com/slowli/tracing-toolbox/> |
| 4 | +
|
| 5 | +use crate::util::*; |
| 6 | +use hashbrown::HashMap; |
| 7 | +use std::{ |
| 8 | + borrow::Cow, |
| 9 | + sync::{LazyLock, OnceLock, RwLock}, |
| 10 | +}; |
| 11 | +use tracing_core::{field::FieldSet, metadata::Level, Dispatch, Kind, Metadata}; |
| 12 | + |
| 13 | +/// Registry of dynamic tracing metadata generated from Flecs |
| 14 | +pub(crate) static REGISTRY: LazyLock<RwLock<Registry>> = LazyLock::new(Default::default); |
| 15 | + |
| 16 | +/// Registry of dynamic tracing metadata generated from Flecs |
| 17 | +pub(crate) struct Registry { |
| 18 | + pub(crate) metadata: HashMap<MetadataRequest<'static>, &'static Metadata<'static>>, |
| 19 | +} |
| 20 | + |
| 21 | +impl Default for Registry { |
| 22 | + fn default() -> Self { |
| 23 | + Self { |
| 24 | + // Capacity was chosen arbitrarily |
| 25 | + metadata: HashMap::with_capacity(256), |
| 26 | + } |
| 27 | + } |
| 28 | +} |
| 29 | + |
| 30 | +pub(crate) fn init() { |
| 31 | + LazyLock::force(®ISTRY); |
| 32 | +} |
| 33 | + |
| 34 | +#[derive(Default)] |
| 35 | +pub(crate) struct DynamicCallsite { |
| 36 | + /// Due to the opaque [`tracing_core::callsite::Identifier`], |
| 37 | + /// which borrows [`tracing_core::Callsite`] for `'static`, have to use interior mutability. |
| 38 | + /// |
| 39 | + /// See [`MetadataRequest::register`] for details |
| 40 | + pub(crate) metadata: OnceLock<Metadata<'static>>, |
| 41 | +} |
| 42 | + |
| 43 | +impl tracing_core::Callsite for DynamicCallsite { |
| 44 | + fn set_interest(&self, _interest: tracing_core::Interest) { |
| 45 | + // No-op |
| 46 | + } |
| 47 | + |
| 48 | + fn metadata(&self) -> &Metadata<'_> { |
| 49 | + self.metadata.get().unwrap() |
| 50 | + } |
| 51 | +} |
| 52 | + |
| 53 | +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
| 54 | +pub(crate) enum MetadataKind { |
| 55 | + // hash/eq skip filename/line since they may differ between start & stop |
| 56 | + // only used when perf_trace is enabled |
| 57 | + #[cfg_attr(not(feature = "perf_trace"), allow(unused))] |
| 58 | + Span, |
| 59 | + Event, |
| 60 | +} |
| 61 | + |
| 62 | +#[derive(Clone, Debug)] |
| 63 | +pub(crate) struct MetadataRequest<'a> { |
| 64 | + pub(crate) kind: MetadataKind, |
| 65 | + pub(crate) level: Level, |
| 66 | + pub(crate) name: Cow<'a, str>, |
| 67 | + pub(crate) filename: Option<Cow<'a, str>>, |
| 68 | + pub(crate) line: Option<u32>, |
| 69 | +} |
| 70 | + |
| 71 | +impl<'a> PartialEq for MetadataRequest<'a> { |
| 72 | + fn eq(&self, other: &Self) -> bool { |
| 73 | + self.kind == other.kind |
| 74 | + && self.name == other.name |
| 75 | + && self.level == other.level |
| 76 | + && match self.kind { |
| 77 | + MetadataKind::Span => true, |
| 78 | + MetadataKind::Event => self.filename == other.filename && self.line == other.line, |
| 79 | + } |
| 80 | + } |
| 81 | +} |
| 82 | + |
| 83 | +impl<'a> Eq for MetadataRequest<'a> {} |
| 84 | + |
| 85 | +impl<'a> std::hash::Hash for MetadataRequest<'a> { |
| 86 | + fn hash<H: std::hash::Hasher>(&self, state: &mut H) { |
| 87 | + self.kind.hash(state); |
| 88 | + self.name.hash(state); |
| 89 | + self.level.hash(state); |
| 90 | + match self.kind { |
| 91 | + MetadataKind::Span => {} |
| 92 | + MetadataKind::Event => { |
| 93 | + self.filename.hash(state); |
| 94 | + self.line.hash(state); |
| 95 | + } |
| 96 | + } |
| 97 | + } |
| 98 | +} |
| 99 | + |
| 100 | +impl<'a> MetadataRequest<'a> { |
| 101 | + /// Construct a new [`Metadata`]. |
| 102 | + /// |
| 103 | + /// Does not interact with [`crate::REGISTRY`] by design to avoid having to deal with locking; |
| 104 | + /// the caller should handle memoization if necessary. |
| 105 | + pub(crate) fn register( |
| 106 | + self, |
| 107 | + dispatch: &Dispatch, |
| 108 | + ) -> (&'static Metadata<'static>, MetadataRequest<'static>) { |
| 109 | + // `Dispatch::register_callsite` demands `&'static Metadata`, this is the simplest way to get that |
| 110 | + let callsite = Box::leak(Box::new(DynamicCallsite::default())); |
| 111 | + |
| 112 | + // This macro is the only 'public' way of constructing [`Identifier`] |
| 113 | + let id = tracing_core::identify_callsite!(callsite); |
| 114 | + |
| 115 | + let name = leak_cowstr(self.name); |
| 116 | + let filename: Option<&'static str> = self.filename.map(leak_cowstr); |
| 117 | + |
| 118 | + let metadata = Metadata::new( |
| 119 | + name, |
| 120 | + "flecs", |
| 121 | + self.level, |
| 122 | + filename, |
| 123 | + self.line, |
| 124 | + Some("flecs_ecs_tracing"), |
| 125 | + match self.kind { |
| 126 | + MetadataKind::Span { .. } => FieldSet::new(&[], id), |
| 127 | + MetadataKind::Event { .. } => FieldSet::new(&["message"], id), |
| 128 | + }, |
| 129 | + match self.kind { |
| 130 | + MetadataKind::Span { .. } => Kind::SPAN, |
| 131 | + MetadataKind::Event { .. } => Kind::EVENT, |
| 132 | + }, |
| 133 | + ); |
| 134 | + |
| 135 | + // Store the new Metadata |
| 136 | + callsite.metadata.set(metadata).unwrap(); |
| 137 | + |
| 138 | + // Since the `DynamicCallsite` is alive forever we can also use it to get |
| 139 | + // a `&'static` to the metadata, without extra allocations |
| 140 | + let metadata: &'static Metadata = callsite.metadata.get().unwrap(); |
| 141 | + |
| 142 | + // Tell `tracing` subscribers about the new callsite |
| 143 | + dispatch.register_callsite(metadata); |
| 144 | + |
| 145 | + ( |
| 146 | + metadata, |
| 147 | + MetadataRequest { |
| 148 | + name: Cow::Borrowed(name), |
| 149 | + kind: self.kind, |
| 150 | + filename: filename.map(Cow::Borrowed), |
| 151 | + line: self.line, |
| 152 | + level: self.level, |
| 153 | + }, |
| 154 | + ) |
| 155 | + } |
| 156 | +} |
0 commit comments