From b320fa60ad6ef41897ab384f984b4751e5616282 Mon Sep 17 00:00:00 2001 From: WaterWhisperer Date: Tue, 14 Apr 2026 21:36:40 +0800 Subject: [PATCH 1/3] Add option to remove params from traces --- sea-orm-sync/src/database/db_connection.rs | 25 ++++++++++++++--- sea-orm-sync/src/database/mod.rs | 14 ++++++++++ sea-orm-sync/src/database/tracing_spans.rs | 2 +- sea-orm-sync/src/database/transaction.rs | 12 ++++++--- sea-orm-sync/src/driver/mock.rs | 1 + sea-orm-sync/src/driver/proxy.rs | 1 + sea-orm-sync/src/driver/rusqlite.rs | 5 ++++ sea-orm-sync/src/driver/sqlx_mysql.rs | 9 +++++++ sea-orm-sync/src/driver/sqlx_postgres.rs | 9 +++++++ sea-orm-sync/src/driver/sqlx_sqlite.rs | 9 +++++++ src/database/db_connection.rs | 31 +++++++++++++++++++--- src/database/mod.rs | 14 ++++++++++ src/database/tracing_spans.rs | 2 +- src/database/transaction.rs | 12 ++++++--- src/driver/mock.rs | 1 + src/driver/proxy.rs | 1 + src/driver/rusqlite.rs | 5 ++++ src/driver/sqlx_mysql.rs | 9 +++++++ src/driver/sqlx_postgres.rs | 9 +++++++ src/driver/sqlx_sqlite.rs | 9 +++++++ 20 files changed, 166 insertions(+), 14 deletions(-) diff --git a/sea-orm-sync/src/database/db_connection.rs b/sea-orm-sync/src/database/db_connection.rs index 95c0bd9870..053e21e109 100644 --- a/sea-orm-sync/src/database/db_connection.rs +++ b/sea-orm-sync/src/database/db_connection.rs @@ -147,7 +147,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.execute", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -219,7 +219,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_one", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -249,7 +249,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_all", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -587,6 +587,25 @@ impl DatabaseConnection { } impl DatabaseConnection { + #[expect(unused)] + pub(crate) fn get_tracing_statement_logging(&self) -> bool { + match &self.inner { + #[cfg(feature = "sqlx-mysql")] + DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.tracing_statement_logging, + #[cfg(feature = "sqlx-postgres")] + DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.tracing_statement_logging, + #[cfg(feature = "sqlx-sqlite")] + DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.tracing_statement_logging, + #[cfg(feature = "rusqlite")] + DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::Disconnected => true, + #[cfg(feature = "mock")] + DatabaseConnectionType::MockDatabaseConnection(_) => true, + #[cfg(feature = "proxy")] + DatabaseConnectionType::ProxyDatabaseConnection(_) => true, + } + } + /// Get the database backend for this connection /// /// # Panics diff --git a/sea-orm-sync/src/database/mod.rs b/sea-orm-sync/src/database/mod.rs index 2ec4a784f3..ee2a996a4a 100644 --- a/sea-orm-sync/src/database/mod.rs +++ b/sea-orm-sync/src/database/mod.rs @@ -90,6 +90,8 @@ pub struct ConnectOptions { pub(crate) max_lifetime: Option>, /// Enable SQLx statement logging pub(crate) sqlx_logging: bool, + /// Record SQL statements in tracing spans + pub(crate) tracing_statement_logging: bool, /// SQLx statement logging level (ignored if `sqlx_logging` is false) pub(crate) sqlx_logging_level: log::LevelFilter, /// SQLx slow statements logging level (ignored if `sqlx_logging` is false) @@ -231,6 +233,7 @@ impl ConnectOptions { acquire_timeout: None, max_lifetime: None, sqlx_logging: true, + tracing_statement_logging: true, sqlx_logging_level: log::LevelFilter::Info, sqlx_slow_statements_logging_level: log::LevelFilter::Off, sqlx_slow_statements_logging_threshold: Duration::from_secs(1), @@ -344,6 +347,17 @@ impl ConnectOptions { self.sqlx_logging } + /// Enable recording `db.statement` in tracing spans (default true). + pub fn tracing_statement_logging(&mut self, value: bool) -> &mut Self { + self.tracing_statement_logging = value; + self + } + + /// Get whether `db.statement` recording in tracing spans is enabled. + pub fn get_tracing_statement_logging(&self) -> bool { + self.tracing_statement_logging + } + /// Set SQLx statement logging level (default INFO). /// (ignored if `sqlx_logging` is `false`) pub fn sqlx_logging_level(&mut self, level: log::LevelFilter) -> &mut Self { diff --git a/sea-orm-sync/src/database/tracing_spans.rs b/sea-orm-sync/src/database/tracing_spans.rs index ce5e709c8b..57b7a25595 100644 --- a/sea-orm-sync/src/database/tracing_spans.rs +++ b/sea-orm-sync/src/database/tracing_spans.rs @@ -161,7 +161,7 @@ macro_rules! with_db_span { if $record_stmt { span.record("db.statement", $sql); } - span.in_scope($fut) + span.in_scope(|| $fut) } #[cfg(not(feature = "tracing-spans"))] { diff --git a/sea-orm-sync/src/database/transaction.rs b/sea-orm-sync/src/database/transaction.rs index c907335e6d..ea6c52d2e0 100644 --- a/sea-orm-sync/src/database/transaction.rs +++ b/sea-orm-sync/src/database/transaction.rs @@ -23,6 +23,7 @@ pub struct DatabaseTransaction { backend: DbBackend, open: bool, metric_callback: Option, + tracing_statement_logging: bool, } impl std::fmt::Debug for DatabaseTransaction { @@ -37,6 +38,7 @@ impl DatabaseTransaction { conn: Arc>, backend: DbBackend, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -46,6 +48,7 @@ impl DatabaseTransaction { backend, open: true, metric_callback, + tracing_statement_logging, }; let begin_result: Result<(), DbErr> = super::tracing_spans::with_db_span!( @@ -321,7 +324,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.execute", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -437,7 +440,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_one", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -497,7 +500,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_all", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -584,6 +587,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, None, None, None, @@ -600,6 +604,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, None, @@ -615,6 +620,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, options.isolation_level, options.access_mode, options.sqlite_transaction_mode, diff --git a/sea-orm-sync/src/driver/mock.rs b/sea-orm-sync/src/driver/mock.rs index 4057cdf123..b6da76e9f0 100644 --- a/sea-orm-sync/src/driver/mock.rs +++ b/sea-orm-sync/src/driver/mock.rs @@ -270,6 +270,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Mock(inner))), backend, metric_callback, + true, None, None, None, diff --git a/sea-orm-sync/src/driver/proxy.rs b/sea-orm-sync/src/driver/proxy.rs index d8e1e5e072..dd665c090b 100644 --- a/sea-orm-sync/src/driver/proxy.rs +++ b/sea-orm-sync/src/driver/proxy.rs @@ -149,6 +149,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Proxy(inner))), backend, metric_callback, + true, None, None, None, diff --git a/sea-orm-sync/src/driver/rusqlite.rs b/sea-orm-sync/src/driver/rusqlite.rs index 42d6ba54b4..f90974705f 100644 --- a/sea-orm-sync/src/driver/rusqlite.rs +++ b/sea-orm-sync/src/driver/rusqlite.rs @@ -43,6 +43,7 @@ pub struct RusqliteSharedConnection { pub(crate) conn: Arc>, acquire_timeout: Duration, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } /// A loaned connection that supports nested transactions. @@ -175,6 +176,7 @@ impl From for RusqliteSharedConnection { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout: DEFAULT_ACQUIRE_TIMEOUT, metric_callback: None, + tracing_statement_logging: true, } } } @@ -196,6 +198,7 @@ impl RusqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let acquire_timeout = options.acquire_timeout.unwrap_or(DEFAULT_ACQUIRE_TIMEOUT); + let tracing_statement_logging = options.get_tracing_statement_logging(); // TODO handle disable_statement_logging let after_conn = options.after_connect; @@ -244,6 +247,7 @@ impl RusqliteConnector { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout, metric_callback: None, + tracing_statement_logging, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -420,6 +424,7 @@ impl RusqliteSharedConnection { Arc::new(Mutex::new(InnerConnection::Rusqlite(conn))), crate::DbBackend::Sqlite, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/sea-orm-sync/src/driver/sqlx_mysql.rs b/sea-orm-sync/src/driver/sqlx_mysql.rs index 922dfaaf00..1bead56a34 100644 --- a/sea-orm-sync/src/driver/sqlx_mysql.rs +++ b/sea-orm-sync/src/driver/sqlx_mysql.rs @@ -29,6 +29,7 @@ pub struct SqlxMySqlConnector; pub struct SqlxMySqlPoolConnection { pub(crate) pool: MySqlPool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxMySqlPoolConnection { @@ -42,6 +43,7 @@ impl From for SqlxMySqlPoolConnection { SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -61,6 +63,7 @@ impl SqlxMySqlConnector { /// Add configuration options for the MySQL database #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -100,6 +103,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging, }) .into(); @@ -117,6 +121,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -207,6 +212,7 @@ impl SqlxMySqlPoolConnection { DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -228,6 +234,7 @@ impl SqlxMySqlPoolConnection { let transaction = DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -337,6 +344,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_mysql( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -344,6 +352,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::MySql(inner))), crate::DbBackend::MySql, metric_callback, + tracing_statement_logging, isolation_level, access_mode, None, diff --git a/sea-orm-sync/src/driver/sqlx_postgres.rs b/sea-orm-sync/src/driver/sqlx_postgres.rs index 8ef20f3753..d9490da8bc 100644 --- a/sea-orm-sync/src/driver/sqlx_postgres.rs +++ b/sea-orm-sync/src/driver/sqlx_postgres.rs @@ -28,6 +28,7 @@ pub struct SqlxPostgresConnector; pub struct SqlxPostgresPoolConnection { pub(crate) pool: PgPool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxPostgresPoolConnection { @@ -41,6 +42,7 @@ impl From for SqlxPostgresPoolConnection { SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -60,6 +62,7 @@ impl SqlxPostgresConnector { /// Add configuration options for the PostgreSQL database #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -134,6 +137,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging, }) .into(); @@ -151,6 +155,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -241,6 +246,7 @@ impl SqlxPostgresPoolConnection { DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -262,6 +268,7 @@ impl SqlxPostgresPoolConnection { let transaction = DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -372,6 +379,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_postgres( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -379,6 +387,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Postgres(inner))), crate::DbBackend::Postgres, metric_callback, + tracing_statement_logging, isolation_level, access_mode, None, diff --git a/sea-orm-sync/src/driver/sqlx_sqlite.rs b/sea-orm-sync/src/driver/sqlx_sqlite.rs index 9faf9aab97..5147e461db 100644 --- a/sea-orm-sync/src/driver/sqlx_sqlite.rs +++ b/sea-orm-sync/src/driver/sqlx_sqlite.rs @@ -29,6 +29,7 @@ pub struct SqlxSqliteConnector; pub struct SqlxSqlitePoolConnection { pub(crate) pool: SqlitePool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxSqlitePoolConnection { @@ -42,6 +43,7 @@ impl From for SqlxSqlitePoolConnection { SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -62,6 +64,7 @@ impl SqlxSqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let mut options = options; + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -110,6 +113,7 @@ impl SqlxSqliteConnector { let pool = SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -135,6 +139,7 @@ impl SqlxSqliteConnector { DatabaseConnectionType::SqlxSqlitePoolConnection(SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -226,6 +231,7 @@ impl SqlxSqlitePoolConnection { DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, @@ -248,6 +254,7 @@ impl SqlxSqlitePoolConnection { let transaction = DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, None, @@ -361,6 +368,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_sqlite( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -369,6 +377,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Sqlite(inner))), crate::DbBackend::Sqlite, metric_callback, + tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/src/database/db_connection.rs b/src/database/db_connection.rs index f08bd0dbdd..857b7ba027 100644 --- a/src/database/db_connection.rs +++ b/src/database/db_connection.rs @@ -148,7 +148,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.execute", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -228,7 +228,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_one", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -264,7 +264,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_all", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.get_tracing_statement_logging(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -633,6 +633,31 @@ impl DatabaseConnection { } impl DatabaseConnection { + #[expect(unused)] + pub(crate) fn get_tracing_statement_logging(&self) -> bool { + match &self.inner { + #[cfg(feature = "sqlx-mysql")] + DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.tracing_statement_logging, + #[cfg(feature = "sqlx-postgres")] + DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => { + conn.tracing_statement_logging + } + #[cfg(feature = "sqlx-sqlite")] + DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => { + conn.tracing_statement_logging + } + #[cfg(feature = "rusqlite")] + DatabaseConnectionType::RusqliteSharedConnection(conn) => { + conn.tracing_statement_logging + } + DatabaseConnectionType::Disconnected => true, + #[cfg(feature = "mock")] + DatabaseConnectionType::MockDatabaseConnection(_) => true, + #[cfg(feature = "proxy")] + DatabaseConnectionType::ProxyDatabaseConnection(_) => true, + } + } + /// Get the database backend for this connection /// /// # Panics diff --git a/src/database/mod.rs b/src/database/mod.rs index 39da6b4e38..1576ef1ce5 100644 --- a/src/database/mod.rs +++ b/src/database/mod.rs @@ -104,6 +104,8 @@ pub struct ConnectOptions { pub(crate) max_lifetime: Option>, /// Enable SQLx statement logging pub(crate) sqlx_logging: bool, + /// Record SQL statements in tracing spans + pub(crate) tracing_statement_logging: bool, /// SQLx statement logging level (ignored if `sqlx_logging` is false) pub(crate) sqlx_logging_level: log::LevelFilter, /// SQLx slow statements logging level (ignored if `sqlx_logging` is false) @@ -247,6 +249,7 @@ impl ConnectOptions { acquire_timeout: None, max_lifetime: None, sqlx_logging: true, + tracing_statement_logging: true, sqlx_logging_level: log::LevelFilter::Info, sqlx_slow_statements_logging_level: log::LevelFilter::Off, sqlx_slow_statements_logging_threshold: Duration::from_secs(1), @@ -360,6 +363,17 @@ impl ConnectOptions { self.sqlx_logging } + /// Enable recording `db.statement` in tracing spans (default true). + pub fn tracing_statement_logging(&mut self, value: bool) -> &mut Self { + self.tracing_statement_logging = value; + self + } + + /// Get whether `db.statement` recording in tracing spans is enabled. + pub fn get_tracing_statement_logging(&self) -> bool { + self.tracing_statement_logging + } + /// Set SQLx statement logging level (default INFO). /// (ignored if `sqlx_logging` is `false`) pub fn sqlx_logging_level(&mut self, level: log::LevelFilter) -> &mut Self { diff --git a/src/database/tracing_spans.rs b/src/database/tracing_spans.rs index 78579c85a1..096f80f915 100644 --- a/src/database/tracing_spans.rs +++ b/src/database/tracing_spans.rs @@ -161,7 +161,7 @@ macro_rules! with_db_span { if $record_stmt { span.record("db.statement", $sql); } - span.in_scope($fut) + span.in_scope(|| $fut) } #[cfg(not(feature = "tracing-spans"))] { diff --git a/src/database/transaction.rs b/src/database/transaction.rs index f71908e1b5..82c2a33480 100644 --- a/src/database/transaction.rs +++ b/src/database/transaction.rs @@ -23,6 +23,7 @@ pub struct DatabaseTransaction { backend: DbBackend, open: bool, metric_callback: Option, + tracing_statement_logging: bool, } impl std::fmt::Debug for DatabaseTransaction { @@ -37,6 +38,7 @@ impl DatabaseTransaction { conn: Arc>, backend: DbBackend, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -46,6 +48,7 @@ impl DatabaseTransaction { backend, open: true, metric_callback, + tracing_statement_logging, }; let begin_result: Result<(), DbErr> = super::tracing_spans::with_db_span!( @@ -341,7 +344,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.execute", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -460,7 +463,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_one", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -520,7 +523,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_all", self.backend, stmt.sql.as_str(), - record_stmt = true, + record_stmt = self.tracing_statement_logging, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -614,6 +617,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, None, None, None, @@ -631,6 +635,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, None, @@ -647,6 +652,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), + self.tracing_statement_logging, options.isolation_level, options.access_mode, options.sqlite_transaction_mode, diff --git a/src/driver/mock.rs b/src/driver/mock.rs index ea087b99bb..c512301de7 100644 --- a/src/driver/mock.rs +++ b/src/driver/mock.rs @@ -271,6 +271,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Mock(inner))), backend, metric_callback, + true, None, None, None, diff --git a/src/driver/proxy.rs b/src/driver/proxy.rs index 062eaa1c5d..c61f4ef6e7 100644 --- a/src/driver/proxy.rs +++ b/src/driver/proxy.rs @@ -149,6 +149,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Proxy(inner))), backend, metric_callback, + true, None, None, None, diff --git a/src/driver/rusqlite.rs b/src/driver/rusqlite.rs index a5bf815de7..e7d1ffdd62 100644 --- a/src/driver/rusqlite.rs +++ b/src/driver/rusqlite.rs @@ -43,6 +43,7 @@ pub struct RusqliteSharedConnection { pub(crate) conn: Arc>, acquire_timeout: Duration, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } /// A loaned connection that supports nested transactions. @@ -175,6 +176,7 @@ impl From for RusqliteSharedConnection { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout: DEFAULT_ACQUIRE_TIMEOUT, metric_callback: None, + tracing_statement_logging: true, } } } @@ -196,6 +198,7 @@ impl RusqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let acquire_timeout = options.acquire_timeout.unwrap_or(DEFAULT_ACQUIRE_TIMEOUT); + let tracing_statement_logging = options.get_tracing_statement_logging(); // TODO handle disable_statement_logging let after_conn = options.after_connect; @@ -244,6 +247,7 @@ impl RusqliteConnector { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout, metric_callback: None, + tracing_statement_logging, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -420,6 +424,7 @@ impl RusqliteSharedConnection { Arc::new(Mutex::new(InnerConnection::Rusqlite(conn))), crate::DbBackend::Sqlite, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/src/driver/sqlx_mysql.rs b/src/driver/sqlx_mysql.rs index ed801c769d..0a1e3ab68d 100644 --- a/src/driver/sqlx_mysql.rs +++ b/src/driver/sqlx_mysql.rs @@ -29,6 +29,7 @@ pub struct SqlxMySqlConnector; pub struct SqlxMySqlPoolConnection { pub(crate) pool: MySqlPool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxMySqlPoolConnection { @@ -42,6 +43,7 @@ impl From for SqlxMySqlPoolConnection { SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -61,6 +63,7 @@ impl SqlxMySqlConnector { /// Add configuration options for the MySQL database #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -101,6 +104,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging, }) .into(); @@ -118,6 +122,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -208,6 +213,7 @@ impl SqlxMySqlPoolConnection { DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -234,6 +240,7 @@ impl SqlxMySqlPoolConnection { let transaction = DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -344,6 +351,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_mysql( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -351,6 +359,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::MySql(inner))), crate::DbBackend::MySql, metric_callback, + tracing_statement_logging, isolation_level, access_mode, None, diff --git a/src/driver/sqlx_postgres.rs b/src/driver/sqlx_postgres.rs index 58f1864129..62e65f87e2 100644 --- a/src/driver/sqlx_postgres.rs +++ b/src/driver/sqlx_postgres.rs @@ -28,6 +28,7 @@ pub struct SqlxPostgresConnector; pub struct SqlxPostgresPoolConnection { pub(crate) pool: PgPool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxPostgresPoolConnection { @@ -41,6 +42,7 @@ impl From for SqlxPostgresPoolConnection { SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -60,6 +62,7 @@ impl SqlxPostgresConnector { /// Add configuration options for the PostgreSQL database #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -139,6 +142,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging, }) .into(); @@ -156,6 +160,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -246,6 +251,7 @@ impl SqlxPostgresPoolConnection { DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -272,6 +278,7 @@ impl SqlxPostgresPoolConnection { let transaction = DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, ) @@ -384,6 +391,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_postgres( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -391,6 +399,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Postgres(inner))), crate::DbBackend::Postgres, metric_callback, + tracing_statement_logging, isolation_level, access_mode, None, diff --git a/src/driver/sqlx_sqlite.rs b/src/driver/sqlx_sqlite.rs index cce28aad9e..150cb62015 100644 --- a/src/driver/sqlx_sqlite.rs +++ b/src/driver/sqlx_sqlite.rs @@ -29,6 +29,7 @@ pub struct SqlxSqliteConnector; pub struct SqlxSqlitePoolConnection { pub(crate) pool: SqlitePool, metric_callback: Option, + pub(crate) tracing_statement_logging: bool, } impl std::fmt::Debug for SqlxSqlitePoolConnection { @@ -42,6 +43,7 @@ impl From for SqlxSqlitePoolConnection { SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, } } } @@ -62,6 +64,7 @@ impl SqlxSqliteConnector { #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { let mut options = options; + let tracing_statement_logging = options.get_tracing_statement_logging(); let mut sqlx_opts = options .url .parse::() @@ -111,6 +114,7 @@ impl SqlxSqliteConnector { let pool = SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -136,6 +140,7 @@ impl SqlxSqliteConnector { DatabaseConnectionType::SqlxSqlitePoolConnection(SqlxSqlitePoolConnection { pool, metric_callback: None, + tracing_statement_logging: true, }) .into() } @@ -227,6 +232,7 @@ impl SqlxSqlitePoolConnection { DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, @@ -254,6 +260,7 @@ impl SqlxSqlitePoolConnection { let transaction = DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), + self.tracing_statement_logging, isolation_level, access_mode, None, @@ -369,6 +376,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_sqlite( inner: PoolConnection, metric_callback: Option, + tracing_statement_logging: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -377,6 +385,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Sqlite(inner))), crate::DbBackend::Sqlite, metric_callback, + tracing_statement_logging, isolation_level, access_mode, sqlite_transaction_mode, From b1ec898f80542db0711d1181d53b0e599ff15d6f Mon Sep 17 00:00:00 2001 From: WaterWhisperer Date: Wed, 15 Apr 2026 10:27:38 +0800 Subject: [PATCH 2/3] make sync and fix typos --- DEVELOPMENT.md | 2 +- sea-orm-sync/src/database/db_connection.rs | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md index 50e3b1629f..748156da16 100644 --- a/DEVELOPMENT.md +++ b/DEVELOPMENT.md @@ -40,7 +40,7 @@ cargo test --doc ### Launch some databases -There is a docker compose under `build-tools`, but usually I just pick the ones I need from `build-tools/docker-crete.sh`: +There is a docker compose under `build-tools`, but usually I just pick the ones I need from `build-tools/docker-create.sh`: ```sh docker run \ diff --git a/sea-orm-sync/src/database/db_connection.rs b/sea-orm-sync/src/database/db_connection.rs index 053e21e109..a40ea93f7c 100644 --- a/sea-orm-sync/src/database/db_connection.rs +++ b/sea-orm-sync/src/database/db_connection.rs @@ -593,11 +593,17 @@ impl DatabaseConnection { #[cfg(feature = "sqlx-mysql")] DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.tracing_statement_logging, #[cfg(feature = "sqlx-postgres")] - DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => { + conn.tracing_statement_logging + } #[cfg(feature = "sqlx-sqlite")] - DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => { + conn.tracing_statement_logging + } #[cfg(feature = "rusqlite")] - DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::RusqliteSharedConnection(conn) => { + conn.tracing_statement_logging + } DatabaseConnectionType::Disconnected => true, #[cfg(feature = "mock")] DatabaseConnectionType::MockDatabaseConnection(_) => true, From 8023859715a9ffc63f8ef03785a9b665efacb73a Mon Sep 17 00:00:00 2001 From: WaterWhisperer Date: Wed, 15 Apr 2026 21:32:54 +0800 Subject: [PATCH 3/3] Rename `tracing_statement_logging` to `record_stmt_in_spans` --- sea-orm-sync/src/database/db_connection.rs | 22 ++++++++-------------- sea-orm-sync/src/database/mod.rs | 12 ++++++------ sea-orm-sync/src/database/transaction.rs | 18 +++++++++--------- sea-orm-sync/src/driver/rusqlite.rs | 10 +++++----- sea-orm-sync/src/driver/sqlx_mysql.rs | 18 +++++++++--------- sea-orm-sync/src/driver/sqlx_postgres.rs | 18 +++++++++--------- sea-orm-sync/src/driver/sqlx_sqlite.rs | 18 +++++++++--------- src/database/db_connection.rs | 22 ++++++++-------------- src/database/mod.rs | 12 ++++++------ src/database/transaction.rs | 18 +++++++++--------- src/driver/rusqlite.rs | 10 +++++----- src/driver/sqlx_mysql.rs | 18 +++++++++--------- src/driver/sqlx_postgres.rs | 18 +++++++++--------- src/driver/sqlx_sqlite.rs | 18 +++++++++--------- 14 files changed, 110 insertions(+), 122 deletions(-) diff --git a/sea-orm-sync/src/database/db_connection.rs b/sea-orm-sync/src/database/db_connection.rs index a40ea93f7c..3bc1841946 100644 --- a/sea-orm-sync/src/database/db_connection.rs +++ b/sea-orm-sync/src/database/db_connection.rs @@ -147,7 +147,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.execute", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -219,7 +219,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_one", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -249,7 +249,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_all", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -588,22 +588,16 @@ impl DatabaseConnection { impl DatabaseConnection { #[expect(unused)] - pub(crate) fn get_tracing_statement_logging(&self) -> bool { + pub(crate) fn get_record_stmt_in_spans(&self) -> bool { match &self.inner { #[cfg(feature = "sqlx-mysql")] - DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "sqlx-postgres")] - DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "sqlx-sqlite")] - DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "rusqlite")] - DatabaseConnectionType::RusqliteSharedConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.record_stmt_in_spans, DatabaseConnectionType::Disconnected => true, #[cfg(feature = "mock")] DatabaseConnectionType::MockDatabaseConnection(_) => true, diff --git a/sea-orm-sync/src/database/mod.rs b/sea-orm-sync/src/database/mod.rs index ee2a996a4a..0d9c2d4741 100644 --- a/sea-orm-sync/src/database/mod.rs +++ b/sea-orm-sync/src/database/mod.rs @@ -91,7 +91,7 @@ pub struct ConnectOptions { /// Enable SQLx statement logging pub(crate) sqlx_logging: bool, /// Record SQL statements in tracing spans - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, /// SQLx statement logging level (ignored if `sqlx_logging` is false) pub(crate) sqlx_logging_level: log::LevelFilter, /// SQLx slow statements logging level (ignored if `sqlx_logging` is false) @@ -233,7 +233,7 @@ impl ConnectOptions { acquire_timeout: None, max_lifetime: None, sqlx_logging: true, - tracing_statement_logging: true, + record_stmt_in_spans: true, sqlx_logging_level: log::LevelFilter::Info, sqlx_slow_statements_logging_level: log::LevelFilter::Off, sqlx_slow_statements_logging_threshold: Duration::from_secs(1), @@ -348,14 +348,14 @@ impl ConnectOptions { } /// Enable recording `db.statement` in tracing spans (default true). - pub fn tracing_statement_logging(&mut self, value: bool) -> &mut Self { - self.tracing_statement_logging = value; + pub fn record_stmt_in_spans(&mut self, value: bool) -> &mut Self { + self.record_stmt_in_spans = value; self } /// Get whether `db.statement` recording in tracing spans is enabled. - pub fn get_tracing_statement_logging(&self) -> bool { - self.tracing_statement_logging + pub fn get_record_stmt_in_spans(&self) -> bool { + self.record_stmt_in_spans } /// Set SQLx statement logging level (default INFO). diff --git a/sea-orm-sync/src/database/transaction.rs b/sea-orm-sync/src/database/transaction.rs index ea6c52d2e0..5e4fa221aa 100644 --- a/sea-orm-sync/src/database/transaction.rs +++ b/sea-orm-sync/src/database/transaction.rs @@ -23,7 +23,7 @@ pub struct DatabaseTransaction { backend: DbBackend, open: bool, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, } impl std::fmt::Debug for DatabaseTransaction { @@ -38,7 +38,7 @@ impl DatabaseTransaction { conn: Arc>, backend: DbBackend, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -48,7 +48,7 @@ impl DatabaseTransaction { backend, open: true, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, }; let begin_result: Result<(), DbErr> = super::tracing_spans::with_db_span!( @@ -324,7 +324,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.execute", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -440,7 +440,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_one", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -500,7 +500,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_all", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock(); @@ -587,7 +587,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, None, None, None, @@ -604,7 +604,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, None, @@ -620,7 +620,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, options.isolation_level, options.access_mode, options.sqlite_transaction_mode, diff --git a/sea-orm-sync/src/driver/rusqlite.rs b/sea-orm-sync/src/driver/rusqlite.rs index f90974705f..a43f76773d 100644 --- a/sea-orm-sync/src/driver/rusqlite.rs +++ b/sea-orm-sync/src/driver/rusqlite.rs @@ -43,7 +43,7 @@ pub struct RusqliteSharedConnection { pub(crate) conn: Arc>, acquire_timeout: Duration, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } /// A loaned connection that supports nested transactions. @@ -176,7 +176,7 @@ impl From for RusqliteSharedConnection { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout: DEFAULT_ACQUIRE_TIMEOUT, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -198,7 +198,7 @@ impl RusqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let acquire_timeout = options.acquire_timeout.unwrap_or(DEFAULT_ACQUIRE_TIMEOUT); - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); // TODO handle disable_statement_logging let after_conn = options.after_connect; @@ -247,7 +247,7 @@ impl RusqliteConnector { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -424,7 +424,7 @@ impl RusqliteSharedConnection { Arc::new(Mutex::new(InnerConnection::Rusqlite(conn))), crate::DbBackend::Sqlite, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/sea-orm-sync/src/driver/sqlx_mysql.rs b/sea-orm-sync/src/driver/sqlx_mysql.rs index 1bead56a34..dbcbbd6caf 100644 --- a/sea-orm-sync/src/driver/sqlx_mysql.rs +++ b/sea-orm-sync/src/driver/sqlx_mysql.rs @@ -29,7 +29,7 @@ pub struct SqlxMySqlConnector; pub struct SqlxMySqlPoolConnection { pub(crate) pool: MySqlPool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxMySqlPoolConnection { @@ -43,7 +43,7 @@ impl From for SqlxMySqlPoolConnection { SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -63,7 +63,7 @@ impl SqlxMySqlConnector { /// Add configuration options for the MySQL database #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -103,7 +103,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }) .into(); @@ -121,7 +121,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -212,7 +212,7 @@ impl SqlxMySqlPoolConnection { DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -234,7 +234,7 @@ impl SqlxMySqlPoolConnection { let transaction = DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -344,7 +344,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_mysql( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -352,7 +352,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::MySql(inner))), crate::DbBackend::MySql, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, None, diff --git a/sea-orm-sync/src/driver/sqlx_postgres.rs b/sea-orm-sync/src/driver/sqlx_postgres.rs index d9490da8bc..61a8a2b091 100644 --- a/sea-orm-sync/src/driver/sqlx_postgres.rs +++ b/sea-orm-sync/src/driver/sqlx_postgres.rs @@ -28,7 +28,7 @@ pub struct SqlxPostgresConnector; pub struct SqlxPostgresPoolConnection { pub(crate) pool: PgPool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxPostgresPoolConnection { @@ -42,7 +42,7 @@ impl From for SqlxPostgresPoolConnection { SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -62,7 +62,7 @@ impl SqlxPostgresConnector { /// Add configuration options for the PostgreSQL database #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -137,7 +137,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }) .into(); @@ -155,7 +155,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -246,7 +246,7 @@ impl SqlxPostgresPoolConnection { DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -268,7 +268,7 @@ impl SqlxPostgresPoolConnection { let transaction = DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -379,7 +379,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_postgres( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -387,7 +387,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Postgres(inner))), crate::DbBackend::Postgres, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, None, diff --git a/sea-orm-sync/src/driver/sqlx_sqlite.rs b/sea-orm-sync/src/driver/sqlx_sqlite.rs index 5147e461db..f383cbf75d 100644 --- a/sea-orm-sync/src/driver/sqlx_sqlite.rs +++ b/sea-orm-sync/src/driver/sqlx_sqlite.rs @@ -29,7 +29,7 @@ pub struct SqlxSqliteConnector; pub struct SqlxSqlitePoolConnection { pub(crate) pool: SqlitePool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxSqlitePoolConnection { @@ -43,7 +43,7 @@ impl From for SqlxSqlitePoolConnection { SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -64,7 +64,7 @@ impl SqlxSqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let mut options = options; - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -113,7 +113,7 @@ impl SqlxSqliteConnector { let pool = SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -139,7 +139,7 @@ impl SqlxSqliteConnector { DatabaseConnectionType::SqlxSqlitePoolConnection(SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -231,7 +231,7 @@ impl SqlxSqlitePoolConnection { DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode, @@ -254,7 +254,7 @@ impl SqlxSqlitePoolConnection { let transaction = DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, None, @@ -368,7 +368,7 @@ impl crate::DatabaseTransaction { pub(crate) fn new_sqlite( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -377,7 +377,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Sqlite(inner))), crate::DbBackend::Sqlite, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/src/database/db_connection.rs b/src/database/db_connection.rs index 857b7ba027..00f154de50 100644 --- a/src/database/db_connection.rs +++ b/src/database/db_connection.rs @@ -148,7 +148,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.execute", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -228,7 +228,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_one", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -264,7 +264,7 @@ impl ConnectionTrait for DatabaseConnection { "sea_orm.query_all", self.get_database_backend(), stmt.sql.as_str(), - record_stmt = self.get_tracing_statement_logging(), + record_stmt = self.get_record_stmt_in_spans(), async { match &self.inner { #[cfg(feature = "sqlx-mysql")] @@ -634,22 +634,16 @@ impl DatabaseConnection { impl DatabaseConnection { #[expect(unused)] - pub(crate) fn get_tracing_statement_logging(&self) -> bool { + pub(crate) fn get_record_stmt_in_spans(&self) -> bool { match &self.inner { #[cfg(feature = "sqlx-mysql")] - DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.tracing_statement_logging, + DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "sqlx-postgres")] - DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "sqlx-sqlite")] - DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.record_stmt_in_spans, #[cfg(feature = "rusqlite")] - DatabaseConnectionType::RusqliteSharedConnection(conn) => { - conn.tracing_statement_logging - } + DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.record_stmt_in_spans, DatabaseConnectionType::Disconnected => true, #[cfg(feature = "mock")] DatabaseConnectionType::MockDatabaseConnection(_) => true, diff --git a/src/database/mod.rs b/src/database/mod.rs index 1576ef1ce5..700f48ead1 100644 --- a/src/database/mod.rs +++ b/src/database/mod.rs @@ -105,7 +105,7 @@ pub struct ConnectOptions { /// Enable SQLx statement logging pub(crate) sqlx_logging: bool, /// Record SQL statements in tracing spans - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, /// SQLx statement logging level (ignored if `sqlx_logging` is false) pub(crate) sqlx_logging_level: log::LevelFilter, /// SQLx slow statements logging level (ignored if `sqlx_logging` is false) @@ -249,7 +249,7 @@ impl ConnectOptions { acquire_timeout: None, max_lifetime: None, sqlx_logging: true, - tracing_statement_logging: true, + record_stmt_in_spans: true, sqlx_logging_level: log::LevelFilter::Info, sqlx_slow_statements_logging_level: log::LevelFilter::Off, sqlx_slow_statements_logging_threshold: Duration::from_secs(1), @@ -364,14 +364,14 @@ impl ConnectOptions { } /// Enable recording `db.statement` in tracing spans (default true). - pub fn tracing_statement_logging(&mut self, value: bool) -> &mut Self { - self.tracing_statement_logging = value; + pub fn record_stmt_in_spans(&mut self, value: bool) -> &mut Self { + self.record_stmt_in_spans = value; self } /// Get whether `db.statement` recording in tracing spans is enabled. - pub fn get_tracing_statement_logging(&self) -> bool { - self.tracing_statement_logging + pub fn get_record_stmt_in_spans(&self) -> bool { + self.record_stmt_in_spans } /// Set SQLx statement logging level (default INFO). diff --git a/src/database/transaction.rs b/src/database/transaction.rs index 82c2a33480..d1be4128b0 100644 --- a/src/database/transaction.rs +++ b/src/database/transaction.rs @@ -23,7 +23,7 @@ pub struct DatabaseTransaction { backend: DbBackend, open: bool, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, } impl std::fmt::Debug for DatabaseTransaction { @@ -38,7 +38,7 @@ impl DatabaseTransaction { conn: Arc>, backend: DbBackend, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -48,7 +48,7 @@ impl DatabaseTransaction { backend, open: true, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, }; let begin_result: Result<(), DbErr> = super::tracing_spans::with_db_span!( @@ -344,7 +344,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.execute", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -463,7 +463,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_one", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -523,7 +523,7 @@ impl ConnectionTrait for DatabaseTransaction { "sea_orm.query_all", self.backend, stmt.sql.as_str(), - record_stmt = self.tracing_statement_logging, + record_stmt = self.record_stmt_in_spans, async { #[cfg(not(feature = "sync"))] let conn = &mut *self.conn.lock().await; @@ -617,7 +617,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, None, None, None, @@ -635,7 +635,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, None, @@ -652,7 +652,7 @@ impl TransactionTrait for DatabaseTransaction { Arc::clone(&self.conn), self.backend, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, options.isolation_level, options.access_mode, options.sqlite_transaction_mode, diff --git a/src/driver/rusqlite.rs b/src/driver/rusqlite.rs index e7d1ffdd62..e3717b84ba 100644 --- a/src/driver/rusqlite.rs +++ b/src/driver/rusqlite.rs @@ -43,7 +43,7 @@ pub struct RusqliteSharedConnection { pub(crate) conn: Arc>, acquire_timeout: Duration, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } /// A loaned connection that supports nested transactions. @@ -176,7 +176,7 @@ impl From for RusqliteSharedConnection { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout: DEFAULT_ACQUIRE_TIMEOUT, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -198,7 +198,7 @@ impl RusqliteConnector { #[instrument(level = "trace")] pub fn connect(options: ConnectOptions) -> Result { let acquire_timeout = options.acquire_timeout.unwrap_or(DEFAULT_ACQUIRE_TIMEOUT); - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); // TODO handle disable_statement_logging let after_conn = options.after_connect; @@ -247,7 +247,7 @@ impl RusqliteConnector { conn: Arc::new(Mutex::new(State::Idle(conn))), acquire_timeout, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -424,7 +424,7 @@ impl RusqliteSharedConnection { Arc::new(Mutex::new(InnerConnection::Rusqlite(conn))), crate::DbBackend::Sqlite, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode, diff --git a/src/driver/sqlx_mysql.rs b/src/driver/sqlx_mysql.rs index 0a1e3ab68d..ea9c5340dd 100644 --- a/src/driver/sqlx_mysql.rs +++ b/src/driver/sqlx_mysql.rs @@ -29,7 +29,7 @@ pub struct SqlxMySqlConnector; pub struct SqlxMySqlPoolConnection { pub(crate) pool: MySqlPool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxMySqlPoolConnection { @@ -43,7 +43,7 @@ impl From for SqlxMySqlPoolConnection { SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -63,7 +63,7 @@ impl SqlxMySqlConnector { /// Add configuration options for the MySQL database #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -104,7 +104,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }) .into(); @@ -122,7 +122,7 @@ impl SqlxMySqlConnector { DatabaseConnectionType::SqlxMySqlPoolConnection(SqlxMySqlPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -213,7 +213,7 @@ impl SqlxMySqlPoolConnection { DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -240,7 +240,7 @@ impl SqlxMySqlPoolConnection { let transaction = DatabaseTransaction::new_mysql( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -351,7 +351,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_mysql( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -359,7 +359,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::MySql(inner))), crate::DbBackend::MySql, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, None, diff --git a/src/driver/sqlx_postgres.rs b/src/driver/sqlx_postgres.rs index 62e65f87e2..e0f3e6d626 100644 --- a/src/driver/sqlx_postgres.rs +++ b/src/driver/sqlx_postgres.rs @@ -28,7 +28,7 @@ pub struct SqlxPostgresConnector; pub struct SqlxPostgresPoolConnection { pub(crate) pool: PgPool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxPostgresPoolConnection { @@ -42,7 +42,7 @@ impl From for SqlxPostgresPoolConnection { SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -62,7 +62,7 @@ impl SqlxPostgresConnector { /// Add configuration options for the PostgreSQL database #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -142,7 +142,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }) .into(); @@ -160,7 +160,7 @@ impl SqlxPostgresConnector { DatabaseConnectionType::SqlxPostgresPoolConnection(SqlxPostgresPoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -251,7 +251,7 @@ impl SqlxPostgresPoolConnection { DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -278,7 +278,7 @@ impl SqlxPostgresPoolConnection { let transaction = DatabaseTransaction::new_postgres( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, ) @@ -391,7 +391,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_postgres( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, ) -> Result { @@ -399,7 +399,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Postgres(inner))), crate::DbBackend::Postgres, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, None, diff --git a/src/driver/sqlx_sqlite.rs b/src/driver/sqlx_sqlite.rs index 150cb62015..b0fc510089 100644 --- a/src/driver/sqlx_sqlite.rs +++ b/src/driver/sqlx_sqlite.rs @@ -29,7 +29,7 @@ pub struct SqlxSqliteConnector; pub struct SqlxSqlitePoolConnection { pub(crate) pool: SqlitePool, metric_callback: Option, - pub(crate) tracing_statement_logging: bool, + pub(crate) record_stmt_in_spans: bool, } impl std::fmt::Debug for SqlxSqlitePoolConnection { @@ -43,7 +43,7 @@ impl From for SqlxSqlitePoolConnection { SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, } } } @@ -64,7 +64,7 @@ impl SqlxSqliteConnector { #[instrument(level = "trace")] pub async fn connect(options: ConnectOptions) -> Result { let mut options = options; - let tracing_statement_logging = options.get_tracing_statement_logging(); + let record_stmt_in_spans = options.get_record_stmt_in_spans(); let mut sqlx_opts = options .url .parse::() @@ -114,7 +114,7 @@ impl SqlxSqliteConnector { let pool = SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging, + record_stmt_in_spans, }; #[cfg(feature = "sqlite-use-returning-for-3_35")] @@ -140,7 +140,7 @@ impl SqlxSqliteConnector { DatabaseConnectionType::SqlxSqlitePoolConnection(SqlxSqlitePoolConnection { pool, metric_callback: None, - tracing_statement_logging: true, + record_stmt_in_spans: true, }) .into() } @@ -232,7 +232,7 @@ impl SqlxSqlitePoolConnection { DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode, @@ -260,7 +260,7 @@ impl SqlxSqlitePoolConnection { let transaction = DatabaseTransaction::new_sqlite( conn, self.metric_callback.clone(), - self.tracing_statement_logging, + self.record_stmt_in_spans, isolation_level, access_mode, None, @@ -376,7 +376,7 @@ impl crate::DatabaseTransaction { pub(crate) async fn new_sqlite( inner: PoolConnection, metric_callback: Option, - tracing_statement_logging: bool, + record_stmt_in_spans: bool, isolation_level: Option, access_mode: Option, sqlite_transaction_mode: Option, @@ -385,7 +385,7 @@ impl crate::DatabaseTransaction { Arc::new(Mutex::new(crate::InnerConnection::Sqlite(inner))), crate::DbBackend::Sqlite, metric_callback, - tracing_statement_logging, + record_stmt_in_spans, isolation_level, access_mode, sqlite_transaction_mode,