AsyncLens – A native Rust watchdog for Python Asyncio event loops

Guénaël LABOIS — Fri, 23 Oct 2026 15:33:41 +0000

Hey everyone, I wanted to share his project I've been working on.

I was frustrated by how difficult it is to detect silent event loop starvation in Python asynchronous applications. In production, a single misplaced synchronous blocking call (like an un-awaited database driver or a legacy third-party API request) can completely paralyze the main loop. This causes massive request queuing and timeouts down the line, without ever throwing a single error or exception.

To solve this, I built AsyncLens: an ultra-lightweight, low-overhead event loop watchdog with a monitoring core written entirely in Rust using PyO3.

How it works:
Unlike traditional Python-based profilers that can suffer from GIL contention or alter execution timings, AsyncLens spawns a native OS thread entirely outside of the Python execution path.

Before sleeping for half of the user-defined threshold (e.g., 50ms), the Rust thread arms an atomic witness boolean (using AtomicBool with Relaxed ordering).
On the Python side, a lightweight, continuous asyncio coroutine task continuously resets this atomic witness via a heartbeat.
If a synchronous task blocks the main thread, the Python event loop fails to trigger its heartbeats.
Upon waking up, the Rust thread detects that the witness is still false. It safely attaches to the Python interpreter, captures a surgical snapshot of the execution frames, filters out framework noise, and routes the exact offending lines of code directly to your application's configured logging pipeline (honoring custom formatters like JSON logs).

I designed it to be completely framework-agnostic. It works out-of-the-box for raw asyncio scripts, task queue workers, or modern web frameworks like FastAPI and Starlette via standard lifecycle context managers (async with).

Another issue I wanted to fix was "log storming" and alert fatigue. If a server experiences a cascade of blocked requests for the same function, traditional tools spam your logs. AsyncLens implements a deterministic state machine to group cascading thread freezes into a single, clean timeline block—firing a single alert when the loop stalls and a single recovery update when traffic resumes. To achieve an elegant code design, I also decoupled the asyncio standard core from the optional AnyIO layer into separate, lean modules to avoid importing unused dependencies.

The local core module is fully open-source (Apache 2.0) and ready to play with. I am currently working on a premium cloud-delivery transport that safely forwards these native snapshots to a centralized dashboard and webhooks (Slack/Discord) without impeding application performance.

I would love to get your feedback on the PyO3 threading architecture, the atomic sync model, or any edge cases you foresee in heavy production workloads.

GitHub: https://github.com/AsyncLensTech/AsyncLens
PyPI: https://pypi.org/project/asynclens/
Pro Waitlist: https://forms.gle/pnBG3HrRtrRwzfYG9
Thanks!

DEV Community: Guénaël LABOIS

AsyncLens – A native Rust watchdog for Python Asyncio event loops