Struct TracedConnection 

pub struct TracedConnection { /* private fields */ }

A traced wrapper around SeaORM’s DatabaseConnection.

This wrapper implements ConnectionTrait, StreamTrait, and TransactionTrait, making it a drop-in replacement for DatabaseConnection. All database operations are automatically instrumented with tracing spans.

Span Nesting

Spans created by TracedConnection automatically become children of the current tracing span context. This means if you’re using tracing middleware in your web framework (e.g., tower-http’s TraceLayer), database spans will appear nested under HTTP request spans in your traces.

Example

use sea_orm::Database;
use sea_orm_tracing::TracedConnection;

let db = Database::connect("postgres://localhost/mydb").await?;
let traced = TracedConnection::from(db);

// All queries are now traced
let users = Users::find().all(&traced).await?;

Implementations

impl TracedConnection

pub fn new(connection: DatabaseConnection, config: TracingConfig) -> Self

Create a new traced connection with the given configuration.

pub fn wrap(connection: DatabaseConnection) -> Self

Create a new traced connection with default configuration.

pub fn inner(&self) -> &DatabaseConnection

Get a reference to the underlying DatabaseConnection.

pub fn config(&self) -> &TracingConfig

Get the tracing configuration.

pub fn into_inner(self) -> DatabaseConnection

Consume the wrapper and return the inner DatabaseConnection.

Trait Implementations

impl AsRef<DatabaseConnection> for TracedConnection

fn as_ref(&self) -> &DatabaseConnection

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TracedConnection

fn clone(&self) -> TracedConnection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConnectionTrait for TracedConnection

fn get_database_backend(&self) -> DbBackend

Fetch the database backend as specified in DbBackend. This depends on feature flags enabled.

fn execute<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement

fn execute_unprepared<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ExecResult, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a unprepared Statement

fn query_one<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<Option<QueryResult>, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement and return a query

fn query_all<'life0, 'async_trait>( &'life0 self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueryResult>, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a Statement and return a collection Vec<QueryResult> on success

fn support_returning(&self) -> bool

Check if the connection supports RETURNING syntax on insert and update

fn is_mock_connection(&self) -> bool

Check if the connection is a test connection for the Mock database

impl Debug for TracedConnection

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

Formats the value using the given formatter.

impl From<DatabaseConnection> for TracedConnection

fn from(connection: DatabaseConnection) -> Self

Converts to this type from the input type.

impl StreamTrait for TracedConnection

type Stream<'a> = <DatabaseConnection as StreamTrait>::Stream<'a>

Create a stream for the QueryResult

fn stream<'a>( &'a self, stmt: Statement, ) -> Pin<Box<dyn Future<Output = Result<Self::Stream<'a>, DbErr>> + Send + 'a>>

Execute a Statement and return a stream of results

impl TransactionTrait for TracedConnection

fn begin<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DatabaseTransaction, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute SQL BEGIN transaction. Returns a Transaction that can be committed or rolled back

fn begin_with_config<'life0, 'async_trait>( &'life0 self, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Pin<Box<dyn Future<Output = Result<DatabaseTransaction, DbErr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute SQL BEGIN transaction with isolation level and/or access mode. Returns a Transaction that can be committed or rolled back

fn transaction<'life0, 'async_trait, F, T, E>( &'life0 self, callback: F, ) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + Send + 'async_trait>>

where F: for<'c> FnOnce(&'c DatabaseTransaction) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>> + Send + 'async_trait, T: Send + 'async_trait, E: Display + Debug + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute the function inside a transaction. If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.

fn transaction_with_config<'life0, 'async_trait, F, T, E>( &'life0 self, callback: F, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>, ) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + Send + 'async_trait>>

where F: for<'c> FnOnce(&'c DatabaseTransaction) -> Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'c>> + Send + 'async_trait, T: Send + 'async_trait, E: Display + Debug + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute the function inside a transaction with isolation level and/or access mode. If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.