Is there a way to track how often the connection pool is exhausted

[wouterdb]

I have an application that should never exhaust its connection pool.
If it does, I would like to print a warning.

1. Is there a way of doing determining if the pool is exhausted other than polling the pool size?
2. Is is correct way to determine if the pool is exhausted exhausted = _pool.get_max_size() - self._pool.get_size() - self._pool.get_idle_size() == 0 or should I just do exhausted = not(_pool._queue),

One way of implementing this would be to check if the queue is empty here before calling get() here https://github.com/MagicStack/asyncpg/blob/master/asyncpg/pool.py#L828 and incrementing a counter if it is empty.

It would not be 100% correct, I assume, but it would still be more accurate then polling?

[Ultroncn]

The subtraction in (2) gives false positives. For example, with max_size=10, five established connections, and all five idle:

10 - 5 - 5 == 0  # reports exhaustion, although nothing is borrowed

The established borrowed count is get_size() - get_idle_size(), so the arithmetic you were aiming for is max_size - (size - idle), with a plus before idle. Even that is a snapshot, not a reliable acquire-queue metric: connection creation/reconnection and other acquisitions can be in flight.

not pool._queue is not a replacement. It is a private asyncio queue, and its boolean value is true even when empty. .empty()/.qsize() would inspect that internal queue, but depending on it couples monitoring to the implementation; a queued holder may also need to establish a connection.

There isn't a public pool-exhaustion callback in the current API. To avoid polling, measure acquisitions at the call site:

from contextlib import asynccontextmanager
import logging
from time import perf_counter

@asynccontextmanager
async def measured_acquire(pool):
    start = perf_counter()
    async with pool.acquire() as connection:
        elapsed = perf_counter() - start
        if elapsed >= 0.05:  # choose a threshold for your workload
            logging.warning("Pool acquisition took %.3fs", elapsed)
        yield connection

Use async with measured_acquire(pool) as connection: wherever the app borrows connections. Track this as acquisition latency, rather than an exact exhaustion count: it includes connection setup as well as waiting for a holder. An acquisition timeout likewise does not by itself prove pool saturation.

I checked the getter arithmetic and queue boolean behavior with asyncpg 0.32.0, including a pool initialized without connecting to PostgreSQL; I did not run a database/load test. The relevant public getters and acquisition path are in asyncpg/pool.py.