Struct PostgresRateLimitCounter 

pub struct PostgresRateLimitCounter { /* private fields */ }

A RateLimitCounter backed by a PostgreSQL table.

Suits a deployment already sharing a PostgreSQL task store: no second piece of infrastructure, and the counter is as available as the store the agent already depends on.

It is not the fastest possible shared counter — an in-memory keyspace like Redis will beat a durable table — and that is the trade being made. A deployment that needs the last microsecond implements RateLimitCounter against Redis instead; the trait exists so that is a few lines rather than a fork.

Implementations

impl PostgresRateLimitCounter

pub async fn new(url: &str) -> A2aResult<Self>

Connects to url and creates the counter table if it is absent.

Durability, deliberately traded away

Sessions on this pool run with synchronous_commit = off, so an increment is not waiting on a WAL fsync. Measured on loopback, that is the difference between 598us and 232us per request — the fsync was almost two thirds of the cost.

It is the right trade for this data specifically, and would not be for most: a rate-limit count describes one window, is superseded when the window rolls, and is swept away shortly after. The worst a crash can do is forget that a caller had used part of its budget in the last moments before it — which lets a few extra requests through, once, on a server that has just restarted.

The setting is scoped to the pool this constructor owns. from_pool deliberately does not apply it: the pool handed in there is usually the task store’s, and quietly making a task store non-durable to speed up a counter would be an appalling thing to do behind a caller’s back. A caller who wants both can say so on their own pool.

Errors

A2aError::internal if the database cannot be reached or the table cannot be created.

pub async fn from_pool(pool: PgPool) -> A2aResult<Self>

Uses an existing pool — the usual choice when the deployment already has one for its task store, so the limiter adds no connections.

Unlike new, this leaves the pool’s settings exactly as the caller configured them, including durability. That costs roughly 2.8x per request against a pool with synchronous_commit = off, and it is not this constructor’s call to make on a pool it does not own.

Errors

A2aError::internal if the table cannot be created.

Trait Implementations

impl Debug for PostgresRateLimitCounter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl RateLimitCounter for PostgresRateLimitCounter

fn count<'a>( &'a self, key: &'a str, window: u64, _window_secs: u64, ) -> Pin<Box<dyn Future<Output = A2aResult<u64>> + Send + 'a>>

Counts one request against key in window, returning the new total.