Is it possible to deduplicate data emitted in child spans?

[jssblck]

I have (anonymized) span data that looks like this:

  2024-03-08T21:24:22.931480Z TRACE algorithm::index: matched files, matched_path_count: 578, package_file_count: 578, matched_file_count: 578
    in algorithm::index::fn_c with self: Index { cache_size: 1415, file_count: 1383, package_count: 2, release_count: 30, package_match_count: 1116, release_match_count: 3752 }, package: package_a, files: 1383
    in algorithm::index::fn_b with self: Index { cache_size: 1415, file_count: 1383, package_count: 2, release_count: 30, package_match_count: 1116, release_match_count: 3752 }, package: package_a, files: 1383
    in algorithm::index::fn_a with self: Index { cache_size: 1415, file_count: 1383, package_count: 2, release_count: 30, package_match_count: 1116, release_match_count: 3752 }, files: 1383
    in worker::investigate with id: WpYAoa
    in worker::cmd::main

These functions (algorithm::index::fn_a, fn_b, and fn_c) are all pub because they can be called in different contexts, but when they're called in this nested context I'd love to deduplicate the Index trace data.

Is there a way to do this? I'm using #[tracing::instrument] today, so ideally a way that lets me continue doing so, but if it's more complicated that's fine too.

Thanks in advance for any help! ❤️

[hawkw]

Unfortunately, there isn't really a way to do this automatically that doesn't introduce undesirable overhead --- something like storing all span fields in a hashmap so that we can skip formatting duplicates would have an unacceptable performance cost. When I have a nested call stack of functions that are all instrumented, I've occasionally factored out a private version of the shared code that isn't instrumented, to avoid duplicate spans.

For example, this:

#[instrument]
pub fn do_thing_with_stuff(thing: Thing, stuff: Stuff) { 
    do_thing(thing) 
    // ...
}

#[instrument]
pub fn do_thing(thing: Thing) {
   // ...
}

might become this:

#[instrument]
pub fn do_thing_with_stuff(thing: Thing, stuff: Stuff) { 
    do_thing_inner(thing) 
    // ...
}
 
#[instrument]
pub fn do_thing(thing: Thing) {
    do_thing_inner(thing)
}

fn do_thing_inner(thing: Thing) {
   // ...
}

to avoid formatting Thing twice when calling do_thing_with_stuff. This is, admittedly, a bit of a bother and may not work in your particular use-case.

[jssblck]

yeah, that refactoring format is fine and what i was planning to do if needed. it's a little tedious but not that bad, certainly better than expensive overhead.

thanks for the quick response!

[hawkw]

Glad I could help! :)