Remove dashmap and replace with static array

Cargo.toml

@@ -23,9 +23,8 @@ tracing-core = {version = "0.1", default-features = false}
 tracing-subscriber = {version="0.3", default-features = false, features=["std", "fmt", "registry"]}
 chrono = {version="0.4", default-features = false, features=["std"]}
 once_cell = ">=1.18"
-dashmap = "6"
 paste = "1"
-thiserror = "1"
+thiserror = {version="2", default-features = false}
 
 [target.'cfg(not(target_os = "linux"))'.dependencies]
 tracelogging = ">= 1.2.0"

src/_details.rs

@@ -12,3 +12,12 @@ pub struct EventMetadata {
     pub identity: tracing::callsite::Identifier,
     pub event_tag: u32,
 }
+
+// A EventMetadata with the identity replaced by its hash, because Identity doesn't implement comparisons
+// but we need a stable ordering.
+#[derive(Clone)]
+pub(crate) struct ParsedEventMetadata {
+    pub(crate) identity_hash: u64,
+    pub(crate) kw: u64,
+    pub(crate) event_tag: u32
+}

src/layer/filter.rs

@@ -1,7 +1,7 @@
 use tracing::Subscriber;
 use tracing_subscriber::{layer::Filter, registry::LookupSpan};
 
-use crate::{native::{EventWriter, ProviderTypes}, statics::EVENT_METADATA};
+use crate::{native::{EventWriter, ProviderTypes}, statics::get_event_metadata};
 
 use super::*;
 
@@ -15,7 +15,7 @@ where
         &self,
         metadata: &'static tracing::Metadata<'static>,
     ) -> tracing::subscriber::Interest {
-        let etw_meta = EVENT_METADATA.get(&metadata.callsite());
+        let etw_meta = get_event_metadata(&metadata.callsite());
         let keyword = if let Some(meta) = etw_meta {
             meta.kw
         } else {

src/layer/layer_impl.rs

@@ -35,7 +35,7 @@ where
         &self,
         metadata: &'static tracing::Metadata<'static>,
     ) -> tracing::subscriber::Interest {
-        let etw_meta = EVENT_METADATA.get(&metadata.callsite());
+        let etw_meta = get_event_metadata(&metadata.callsite());
         let keyword = if let Some(meta) = etw_meta {
             meta.kw
         } else {
@@ -84,7 +84,7 @@ where
             .event_span(event)
             .map_or(0, |evt| evt.parent().map_or(0, |p| p.id().into_u64()));
 
-        let etw_meta = EVENT_METADATA.get(&event.metadata().callsite());
+        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)
         } else {
@@ -203,7 +203,7 @@ where
             return;
         };
 
-        let etw_meta = EVENT_METADATA.get(&metadata.callsite());
+        let etw_meta = get_event_metadata(&metadata.callsite());
         let (keyword, tag) = if let Some(meta) = etw_meta {
             (meta.kw, meta.event_tag)
         } else {
@@ -244,7 +244,7 @@ where
             return;
         };
 
-        let etw_meta = EVENT_METADATA.get(&metadata.callsite());
+        let etw_meta = get_event_metadata(&metadata.callsite());
         let (keyword, tag) = if let Some(meta) = etw_meta {
             (meta.kw, meta.event_tag)
         } else {

src/layer/mod.rs

@@ -9,7 +9,7 @@ use tracing::Subscriber;
 use tracing_core::callsite;
 use tracing_subscriber::registry::LookupSpan;
 
-use crate::{native::{EventWriter, ProviderTypes}, statics::EVENT_METADATA};
+use crate::{native::{EventWriter, ProviderTypes}, statics::get_event_metadata};
 
 pub(crate) struct _EtwLayer<S, Mode: ProviderTypes>
 where
@@ -59,7 +59,7 @@ where
     Mode::Provider: EventWriter<Mode> + 'static,
 {
     fn is_enabled(&self, callsite: &callsite::Identifier, level: &tracing_core::Level) -> bool {
-        let etw_meta = EVENT_METADATA.get(callsite);
+        let etw_meta = get_event_metadata(callsite);
         let keyword = if let Some(meta) = etw_meta {
             meta.kw
         } else {

src/statics.rs

@@ -1,5 +1,7 @@
 // Module for static variables that are used by the crate.
 
+use std::{cmp, hash::{BuildHasher, RandomState}};
+
 pub(crate) static GLOBAL_ACTIVITY_SEED: once_cell::sync::Lazy<[u8; 16]> =
 once_cell::sync::Lazy::new(|| {
         let now = std::time::SystemTime::now()
@@ -14,8 +16,10 @@ once_cell::sync::Lazy::new(|| {
         data
     });
 
+static BH: once_cell::sync::Lazy<RandomState> = once_cell::sync::Lazy::new(|| {RandomState::new()});
+
 pub(crate) static EVENT_METADATA: once_cell::sync::Lazy<
-    dashmap::DashMap<tracing::callsite::Identifier, &'static crate::_details::EventMetadata>,
+    Box<[crate::_details::ParsedEventMetadata]>,
 > = once_cell::sync::Lazy::new(|| {
     unsafe {
         let start =
@@ -30,7 +34,7 @@ pub(crate) static EVENT_METADATA: once_cell::sync::Lazy<
             &mut *core::ptr::slice_from_raw_parts_mut(start, stop.offset_from(start) as usize);
 
         if events_slice.is_empty() {
-            return dashmap::DashMap::new();
+            return Box::new_uninit_slice(0).assume_init();
         }
 
         // Sort spurious nulls to the end
@@ -61,13 +65,44 @@ pub(crate) static EVENT_METADATA: once_cell::sync::Lazy<
             next_pos += 1;
         }
 
-        let map = dashmap::DashMap::with_capacity(events_slice.len());
+        let mut map: Box<[core::mem::MaybeUninit<crate::_details::ParsedEventMetadata>]> = Box::new_uninit_slice(good_pos + 1);
         next_pos = 0;
-        while next_pos < good_pos {
-            let event = &*events_slice[next_pos];
-            map.insert(event.identity.clone(), event);
+        while next_pos <= good_pos {
+            let next = &*events_slice[next_pos];
+            map[next_pos].as_mut_ptr().write(crate::_details::ParsedEventMetadata { identity_hash: BH.hash_one(&next.identity), kw: next.kw, event_tag: next.event_tag });
             next_pos += 1;
         }
-        map
+        let mut sorted = map.assume_init();
+        sorted.sort_unstable_by(|a, b| b.cmp(a));
+        sorted
     }
 });
+
+impl core::cmp::PartialEq for crate::_details::ParsedEventMetadata {
+    fn eq(&self, other: &Self) -> bool {
+        self.identity_hash == other.identity_hash
+    }
+}
+
+impl core::cmp::Eq for crate::_details::ParsedEventMetadata {}
+
+impl core::cmp::PartialOrd for crate::_details::ParsedEventMetadata {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        self.identity_hash.partial_cmp(&other.identity_hash)
+    }
+}
+
+impl core::cmp::Ord for crate::_details::ParsedEventMetadata {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.identity_hash.cmp(&other.identity_hash)
+    }
+}
+
+pub(crate) fn get_event_metadata(id: &tracing::callsite::Identifier) -> Option<&'static crate::_details::ParsedEventMetadata> {
+    let hash = BH.hash_one(id);
+    let etw_meta = EVENT_METADATA.binary_search_by_key(&hash, |m| { m.identity_hash });
+    match etw_meta {
+        Ok(idx) => Some(&EVENT_METADATA[idx]),
+        _ => None
+    }
+}