Struct Pool 

pub struct Pool<DB: Database> { /* private fields */ }

An instrumented wrapper around sqlx::Pool that emits OpenTelemetry spans and metrics for every database operation.

Create one via PoolBuilder:

let pool: Pool<Postgres> = PoolBuilder::from(sqlx_pool).build();

All connections acquired from this pool inherit its shared attributes and metric instruments.

Implementations

impl<DB: Database> Pool<DB>

pub async fn acquire(&self) -> Result<PoolConnection<DB>, Error>

Acquire a pooled connection instrumented for OpenTelemetry.

Records db.client.connection.wait_time (time spent waiting for a connection), tracks db.client.connection.pending_requests, and increments db.client.connection.timeouts on PoolTimedOut.

Errors

Returns sqlx::Error if a connection cannot be obtained from the pool (e.g. timeout, pool closed).

pub async fn begin(&self) -> Result<Transaction<'_, DB>, Error>

Begin a new transaction instrumented for OpenTelemetry.

Errors

Returns sqlx::Error if beginning the transaction fails.

pub async fn close(&self)

Shut down the pool, waiting for all connections to be released.

pub fn is_closed(&self) -> bool

Returns true if the pool has been closed.

pub fn with_annotations( &self, annotations: QueryAnnotations, ) -> Annotated<'_, Self>

Return an annotated executor that attaches per-query semantic convention attributes to every span created by the next operation.

The returned wrapper borrows the pool and implements sqlx::Executor with the same instrumentation, but with annotation values threaded through to span creation.

Example

pool.with_annotations(QueryAnnotations::new()
        .operation("SELECT")
        .collection("users"))
    .fetch_all("SELECT * FROM users")
    .await?;

pub fn with_operation( &self, operation: impl Into<String>, collection: impl Into<String>, ) -> Annotated<'_, Self>

Shorthand for annotating the next operation with db.operation.name and db.collection.name.

Equivalent to self.with_annotations(QueryAnnotations::new().operation(op).collection(coll)).

Trait Implementations

impl<DB: Database> Clone for Pool<DB>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<DB: Debug + Database> Debug for Pool<DB>

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

Formats the value using the given formatter.

impl<'c, DB> Executor<'c> for &Pool<DB>

where DB: Database, for<'a> &'a mut DB::Connection: Executor<'a, Database = DB>,

fn execute<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<DB as Database>::QueryResult, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<DB as Database>::QueryResult, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<DB as Database>::Row, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return the generated results as a stream.

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<<DB as Database>::QueryResult, <DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_all<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Vec<<DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<DB as Database>::Row, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and returns exactly one row.

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<<DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and returns at most one row.

fn prepare<'e, 'q: 'e>( self, query: &'q str, ) -> BoxFuture<'e, Result<<DB as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.

Be advised that when using the query, query_as, or query_scalar functions, the query is transparently prepared and executed.

This explicit API is provided to allow access to the statement metadata available after it prepared but before the first row is returned.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<DB as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<DB as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

Only some database drivers (Postgres, MSSQL) can take advantage of this extra information to influence parameter type inference.

type Database = DB