Rename tracing_statement_logging to record_stmt_in_spans

Author: WaterWhisperer

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,

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).

sea-orm-sync/src/database/transaction.rs

@@ -23,7 +23,7 @@ pub struct DatabaseTransaction {
     backend: DbBackend,
     open: bool,
     metric_callback: Option<crate::metric::Callback>,
-    tracing_statement_logging: bool,
+    record_stmt_in_spans: bool,
 }
 
 impl std::fmt::Debug for DatabaseTransaction {
@@ -38,7 +38,7 @@ impl DatabaseTransaction {
         conn: Arc<Mutex<InnerConnection>>,
         backend: DbBackend,
         metric_callback: Option<crate::metric::Callback>,
-        tracing_statement_logging: bool,
+        record_stmt_in_spans: bool,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
         sqlite_transaction_mode: Option<SqliteTransactionMode>,
@@ -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,

sea-orm-sync/src/driver/rusqlite.rs

@@ -43,7 +43,7 @@ pub struct RusqliteSharedConnection {
     pub(crate) conn: Arc<Mutex<State>>,
     acquire_timeout: Duration,
     metric_callback: Option<crate::metric::Callback>,
-    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<RusqliteConnection> 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<DatabaseConnection, DbErr> {
         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,

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<crate::metric::Callback>,
-    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<MySqlPool> 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<DatabaseConnection, DbErr> {
-        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::<MySqlConnectOptions>()
@@ -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,15 +344,15 @@ impl crate::DatabaseTransaction {
     pub(crate) fn new_mysql(
         inner: PoolConnection<sqlx::MySql>,
         metric_callback: Option<crate::metric::Callback>,
-        tracing_statement_logging: bool,
+        record_stmt_in_spans: bool,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
     ) -> Result<crate::DatabaseTransaction, DbErr> {
         Self::begin(
             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,

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<crate::metric::Callback>,
-    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<PgPool> 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<DatabaseConnection, DbErr> {
-        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::<PgConnectOptions>()
@@ -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,15 +379,15 @@ impl crate::DatabaseTransaction {
     pub(crate) fn new_postgres(
         inner: PoolConnection<sqlx::Postgres>,
         metric_callback: Option<crate::metric::Callback>,
-        tracing_statement_logging: bool,
+        record_stmt_in_spans: bool,
         isolation_level: Option<IsolationLevel>,
         access_mode: Option<AccessMode>,
     ) -> Result<crate::DatabaseTransaction, DbErr> {
         Self::begin(
             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,