Upgrade fastrace to 0.7.9 (#36012)

goffrie · Convex, Inc. · commit 63382f75f53d · 2025-03-31T22:28:28.000Z
&amp; update uses of deprecated APIs (Event::add_to_[local_]parent)

GitOrigin-RevId: cf243b85f9ed72d62446458316dad1545543cfba
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/database/src/committer.rs b/crates/database/src/committer.rs
@@ -308,7 +308,7 @@ impl<RT: Runtime> Committer<RT> {
                     }
                     // Report the trace if it is longer than the threshold
                     if let Some(id) = span_commit_id && id == pending_commit_id {
-                        if let Some(mut span) = committer_span.take() {
+                        if let Some(span) = committer_span.take() {
                             if span.elapsed() < Some(*COMMIT_TRACE_THRESHOLD) {
                                 tracing::debug!("Not sending span to honeycomb because it is below the threshold");
                                 span.cancel();
diff --git a/crates/function_runner/src/metrics.rs b/crates/function_runner/src/metrics.rs
@@ -1,6 +1,7 @@
-use std::borrow::Cow;
-
-use fastrace::Event;
+use fastrace::{
+    local::LocalSpan,
+    Event,
+};
 use metrics::{
     log_counter_with_labels,
     log_distribution,
@@ -86,20 +87,15 @@ pub fn record_module_sizes(source_size: usize, source_map_size: Option<usize>) {
     if let Some(map_size) = source_map_size {
         log_distribution(&MODULE_CACHE_SOURCE_MAP_SIZE_BYTES_TOTAL, map_size as f64);
     }
-    Event::add_to_local_parent("module_cache_get_module", || {
+    LocalSpan::add_event(Event::new("module_cache_get_module").with_properties(|| {
         [
+            ("module_cache_source_size", source_size.to_string()),
             (
-                Cow::Borrowed("module_cache_source_size"),
-                Cow::Owned(source_size.to_string()),
-            ),
-            (
-                Cow::Borrowed("module_cache_source_map_size"),
-                Cow::Owned(
-                    source_map_size
-                        .map(|s| s.to_string())
-                        .unwrap_or("None".to_string()),
-                ),
+                "module_cache_source_map_size",
+                source_map_size
+                    .map(|s| s.to_string())
+                    .unwrap_or("None".to_string()),
             ),
         ]
-    });
+    }));
 }
diff --git a/crates/isolate/src/isolate.rs b/crates/isolate/src/isolate.rs
@@ -1,5 +1,4 @@
 use std::{
-    borrow::Cow,
     collections::BTreeMap,
     ffi,
     ptr,
@@ -22,7 +21,10 @@ use derive_more::{
     AddAssign,
 };
 use errors::ErrorMetadata;
-use fastrace::Event;
+use fastrace::{
+    local::LocalSpan,
+    Event,
+};
 use humansize::{
     FormatSize,
     BINARY,
@@ -351,18 +353,12 @@ extern "C" fn near_heap_limit_callback(
     current_heap_limit: usize,
     initial_heap_limit: usize,
 ) -> usize {
-    Event::add_to_local_parent("isolate_out_of_memory", || {
+    LocalSpan::add_event(Event::new("isolate_out_of_memory").with_properties(|| {
         [
-            (
-                Cow::Borrowed("current_heap_limit"),
-                Cow::Owned(current_heap_limit.to_string()),
-            ),
-            (
-                Cow::Borrowed("initial_heap_limit"),
-                Cow::Owned(initial_heap_limit.to_string()),
-            ),
+            ("current_heap_limit", current_heap_limit.to_string()),
+            ("initial_heap_limit", initial_heap_limit.to_string()),
         ]
-    });
+    }));
     let heap_ctx = unsafe { &mut *(data as *mut HeapContext) };
     heap_ctx.handle.terminate(TerminationReason::OutOfMemory);
 
diff --git a/crates/isolate/src/metrics.rs b/crates/isolate/src/metrics.rs
@@ -11,7 +11,10 @@ use common::{
 };
 use deno_core::v8;
 use errors::ErrorMetadata;
-use fastrace::Event;
+use fastrace::{
+    local::LocalSpan,
+    Event,
+};
 use metrics::{
     log_counter,
     log_counter_with_labels,
@@ -647,7 +650,7 @@ pub fn record_component_function_path(component_function_path: &ResolvedComponen
             Cow::Owned(component_path.to_string()),
         ));
     }
-    Event::add_to_local_parent("component_function_path", || labels);
+    LocalSpan::add_event(Event::new("component_function_path").with_properties(|| labels));
 }
 
 register_convex_counter!(
diff --git a/crates/mysql/src/lib.rs b/crates/mysql/src/lib.rs
@@ -11,7 +11,6 @@ mod metrics;
 #[cfg(test)]
 mod tests;
 use std::{
-    borrow::Cow,
     cmp,
     collections::{
         BTreeMap,
@@ -282,18 +281,12 @@ impl<RT: Runtime> Persistence for MySqlPersistence<RT> {
         }
         metrics::log_write_bytes(write_size);
         metrics::log_write_documents(documents.len());
-        Event::add_to_local_parent("write_to_persistence_size", || {
+        LocalSpan::add_event(Event::new("write_to_persistence_size").with_properties(|| {
             [
-                (
-                    Cow::Borrowed("num_documents"),
-                    Cow::Owned(documents.len().to_string()),
-                ),
-                (
-                    Cow::Borrowed("write_size"),
-                    Cow::Owned(write_size.to_string()),
-                ),
+                ("num_documents", documents.len().to_string()),
+                ("write_size", write_size.to_string()),
             ]
-        });
+        }));
 
         // True, the below might end up failing and not changing anything.
         self.newly_created.store(false, SeqCst);
@@ -329,18 +322,14 @@ impl<RT: Runtime> Persistence for MySqlPersistence<RT> {
                                 tx.exec_drop(insert_chunk_query, insert_document_chunk)
                                     .await?;
                                 timer.finish();
-                                Event::add_to_local_parent("document_smart_chunks", || {
-                                    [
-                                        (
-                                            Cow::Borrowed("chunk_length"),
-                                            Cow::Owned(chunk.len().to_string()),
-                                        ),
-                                        (
-                                            Cow::Borrowed("chunk_bytes"),
-                                            Cow::Owned(chunk_bytes.to_string()),
-                                        ),
-                                    ]
-                                });
+                                LocalSpan::add_event(
+                                    Event::new("document_smart_chunks").with_properties(|| {
+                                        [
+                                            ("chunk_length", chunk.len().to_string()),
+                                            ("chunk_bytes", chunk_bytes.to_string()),
+                                        ]
+                                    }),
+                                );
                                 Ok::<_, anyhow::Error>(())
                             };
                             future
@@ -374,18 +363,14 @@ impl<RT: Runtime> Persistence for MySqlPersistence<RT> {
                                 tx.exec_drop(insert_index_chunk, insert_index_chunk_params)
                                     .await?;
                                 timer.finish();
-                                Event::add_to_local_parent("index_smart_chunks", || {
-                                    [
-                                        (
-                                            Cow::Borrowed("chunk_length"),
-                                            Cow::Owned(chunk.len().to_string()),
-                                        ),
-                                        (
-                                            Cow::Borrowed("chunk_bytes"),
-                                            Cow::Owned(chunk_bytes.to_string()),
-                                        ),
-                                    ]
-                                });
+                                LocalSpan::add_event(
+                                    Event::new("index_smart_chunks").with_properties(|| {
+                                        [
+                                            ("chunk_length", chunk.len().to_string()),
+                                            ("chunk_bytes", chunk_bytes.to_string()),
+                                        ]
+                                    }),
+                                );
                                 Ok::<_, anyhow::Error>(())
                             };
                             future
diff --git a/crates/sync/src/worker.rs b/crates/sync/src/worker.rs
@@ -1,5 +1,4 @@
 use std::{
-    borrow::Cow,
     collections::BTreeMap,
     sync::{
         atomic::{
@@ -504,12 +503,10 @@ impl<RT: Runtime> SyncWorker<RT> {
 
                 let mutation_queue_size =
                     self.mutation_sender.max_capacity() - self.mutation_sender.capacity();
-                Event::add_to_parent("mutation_queue_size", &root, || {
-                    vec![(
-                        Cow::Borrowed("mutation_queue_size"),
-                        Cow::Owned(mutation_queue_size.to_string()),
-                    )]
-                });
+                root.add_event(
+                    Event::new("mutation_queue_size")
+                        .with_property(|| ("mutation_queue_size", mutation_queue_size.to_string())),
+                );
 
                 let future = async move {
                     rt.with_timeout("mutation", SYNC_WORKER_PROCESS_TIMEOUT, async move {

Original file line number	Diff line number	Diff line change
`@@ -308,7 +308,7 @@ impl<RT: Runtime> Committer<RT> {`
`308`	`308`	`}`
`309`	`309`	`// Report the trace if it is longer than the threshold`
`310`	`310`	`if let Some(id) = span_commit_id && id == pending_commit_id {`
`311`		`- if let Some(mut span) = committer_span.take() {`
	`311`	`+ if let Some(span) = committer_span.take() {`
`312`	`312`	`if span.elapsed() < Some(*COMMIT_TRACE_THRESHOLD) {`
`313`	`313`	`tracing::debug!("Not sending span to honeycomb because it is below the threshold");`
`314`	`314`	`span.cancel();`