bytehound VS tracing

I've found bytehound helpful for tracking memory leaks: https://github.com/koute/bytehound

Interesting approach. How is performance compared to something like https://github.com/koute/bytehound

https://github.com/koute/bytehound is another tool in this space to be aware of

If you're on Linux (and since you're considering using Valgrind then you must be) you could use something like my Bytehound; you can also script its analysis, so if you'd be interested in e.g. figuring out which libraries allocate how much you can also do that.

Ot sure if it will fit your needs but maybe bytehound is worth looking into.

I had a great success recently with https://github.com/koute/bytehound/issues/86

For memory you can also try Bytehound, which is a memory profiler I wrote a while back. It's not technically Rust-specific, although it is written in Rust and has Rust-specific features like automatic Rust symbol demangling.

> What's been your biggest issues around ergonomics/amenities for OpenTelemetry?

I can't speak generally, but in the Rust ecosystem the various crates don't play well together. Here's one example: <https://github.com/tokio-rs/tracing/issues/2648> There are four crates involved (tracing-attributes, tracing-opentelemetry, opentelemetry, and opentelemetry-datadog) and none of them fit properly into any of the others.

The tracing (logging) mechanism in an asynchronous codebase (tracing).

Tracing is Tokio's alternative for async code.

At a technical level, in Rust, both [tracing]https://crates.io/crates/tracing) and log are entire ecosystems (though for the latter at least there's also third party logging frameworks), and there's at least a bridge from log to tracing.

I've used the tracing infrastructure with tracing_flame to profile some hot paths in async code: https://github.com/tokio-rs/tracing/tree/master/tracing-flame

Oh nice! IIRC when I checked, it was the Unicode tables that smashed the code size. I recently hit the same issue with the tracing crate, where a crate feature (for env var filtering) pulled in regex and my binary was suddenly 1MB bigger.

I know about tools such as tracing, jaeger or tracy. While having a complete tracing could be a potential solution, these tools don't work with no_std.

tracing by itself only outputs log data, you need to consume them in a subscriber, the tracing-subscriber crate exists for this. (example)

Let's look at some code. We have different ways to create spans in Rust. In this article, we focus on creating spans manually, not covering any abstractions such as tracing.

Is there a standard crate / tool / practice for simplistic logging with Tokio? I presume it's tokio-tracing but there seems to be many bells and whistles when I'm looking for what amounts to essentially an async stderr with concurrent buffering.