console VS tracing

tokio-console is a debugger for Rust async programs that use Tokio. To get started, add the console-subscriber crate to your project and add the following line which will initialise the subscriber and allow tokio-console to connect to it:

You could try https://github.com/tokio-rs/console to debug and profile what happens with tokio tasks in your program.

The tokio-console CLI is a fun one. The console-subscriber supports shipping to a console server running elsewhere, apparently. That gives you a window into what's happening now.

Tokio console maybe? https://github.com/tokio-rs/console

If I add "console_subscriber::init()" line as https://github.com/tokio-rs/console recommends, tracing_subscriber cannot be initialized.

I'm building an HTTP load tester called pdc! I have run out of obvious (to me at least) places to look for performance gains. I'm achieving around 45,000 requests per second, per core. Right now I'm using hyper with a separate tokio runtime (in current thread mode) running on each core. So far having runtime on each core/NUMA node has really helped with cache coherency. Any recommendations for profiling beyond tokio console or tokio metrics (Convenient timing amirite!)?

It was just an accident and has been fixed https://github.com/tokio-rs/console/issues/270.

P.S. Tokio [now also has Tokio Console](https://github.com/tokio-rs/console) allowing you to conveniently troubleshoot your tasks if they are causing issues :)

You can opt-in to async runtime such as tokio, and you can use tokio-rs/console for it's top-like metric

The video description is as follows:

In this stream, we peel back the crust on the tracing crate — https://github.com/tokio-rs/tracing/ — and explore its interface, structure, and mechanisms. We talk about spans, events, their attributes and fields, and how to think about them in async code. We also dig into what subscribers are, how they pick up events, and how you can construct your own subscribers through the layer abstraction. For more details about tracing, see https://docs.rs/tracing/latest/tracing/.

> 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 am using https://github.com/tokio-rs/tracing for logging purposes in my application. I would like to develop a feature wherein logs should be saved to a database table (via sea-orm). Something similar is this, but it does not solve my needs fully.

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)