console VS bytes

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

Many Rust code examples I come across online represent bytes as &[u8] or Vec. However, there is a Bytes crate. Is there any reason for preferring the vector or the slice instead of this crate for bytes?

Take a look at the Bytes crate. With it, one can buffer bytes into a BufMut, and send borrowed slices as Bytes. Once the Bytes are freed, the BufMut takes care of reusing the capacity. Several of the web server frameworks use this, so it's fairly mature.

The project is led by the Tokio community — most of the implementation so far has been done by people who are Tokio project maintainers. Tokio hosts a number of libraries that aren't tightly coupled to the tokio crate's runtime, like prost and bytes. The name just means that the same group of people is committed to working on and maintaining it. :)

Oh an libraries (or the std library) that want to write unsafe code that relies on some Trait's invariant will mark that trait `unsafe`, for example: https://github.com/tokio-rs/bytes/pull/432