tcpproxy VS console

Thanks. Perhaps I did go overboard with that disclaimer.. probably because I myself made the mistake of initially using [0] the oh-so-convenient tokio::io::copy() instead of writing my own copy method that would drop the other half of the connection when one side was closed.

The copy_with_abort() routine is still taking the easy way out in this not-optimized-for-heavy-production-use sample because it uses a broadcast channel per connection to reactively signal that the other half of the connection should be closed (rather than timing out every x ms to see if an abort flag has been set). In the real world, I'd probably replace the join! macro with a manual event loop to be able to do the same but without creating a broadcast channel per-connection.

(I maintain an extremely lightweight "awaitable bools" library for rust [1] that is perfect for this kind of thing (roughly equivalent to a "bounded broadcast_channel<()> of queue length 1, but each "channel" is only a single (optionally stack-allocated) byte) — but it's for event loops in synchronous code and not async executor compatible.)

[0]: https://github.com/mqudsi/tcpproxy/commit/0164ef836a49f2f738...

[1]: https://github.com/neosmart/rsevents

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