use std::collections::BTreeMap;
use serde::Serialize;
use serde_json::Value;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum SqlExecutionMethod {
Execute,
FetchAll,
FetchOptional,
FetchOne,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum SqlExecutionOutcome {
Success,
Failure,
BusinessFailure,
}
#[derive(Clone, Debug, Serialize)]
#[non_exhaustive]
pub struct SqlExecutionError {
pub class: String,
pub message: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint: Option<String>,
}
#[derive(Clone, Debug, Serialize)]
#[non_exhaustive]
pub struct SqlExecution {
pub execution_id: u64,
pub query_name: String,
pub operation: super::SqlOperation,
pub method: SqlExecutionMethod,
pub statement: String,
pub outcome: SqlExecutionOutcome,
pub elapsed_ms: f64,
#[serde(skip_serializing_if = "Option::is_none")]
pub rows_affected: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rows_returned: Option<usize>,
#[serde(skip_serializing_if = "BTreeMap::is_empty")]
pub safe_parameters: BTreeMap<String, Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<SqlExecutionError>,
#[serde(skip_serializing_if = "Option::is_none")]
pub api_error_code: Option<u32>,
}
impl SqlExecution {
#[must_use]
pub const fn is_failure(&self) -> bool {
matches!(
self.outcome,
SqlExecutionOutcome::Failure | SqlExecutionOutcome::BusinessFailure
)
}
}
#[cfg(any(feature = "connection-mysql", feature = "connection-postgres"))]
mod sqlx_support {
use std::{
borrow::Cow,
collections::BTreeMap,
fmt::Display,
future::Future,
time::{Duration, Instant},
};
use serde::Serialize;
use serde_json::Value;
use super::{SqlExecution, SqlExecutionError, SqlExecutionMethod, SqlExecutionOutcome};
use crate::{
observability::{
RequestLogContext, SqlDiagnostic, SqlOperation,
bounded_json::{BoundedJsonValue, to_bounded_json_value},
diagnostic::{
MAX_DETAIL_FIELDS, MAX_DETAIL_JSON_BYTES, MAX_DETAIL_STRING_BYTES, MAX_ERROR_BYTES,
MAX_NAME_BYTES, MAX_STATEMENT_BYTES, bound_json_value, bounded_display,
truncate_owned,
},
sqlx_capture::{SqlxQueryEvent, capture_sqlx_query},
},
web::response::{ApiError, SqlErrorClass, default_sqlx_api_error},
};
#[derive(Debug)]
struct SqlLogMetadata {
query_name: Cow<'static, str>,
operation: SqlOperation,
statement: Cow<'static, str>,
safe_parameters: BTreeMap<String, Value>,
class_errors: BTreeMap<SqlErrorClass, ApiError>,
constraint_errors: BTreeMap<String, ApiError>,
fallback_error: Option<ApiError>,
zero_rows_error: Option<ApiError>,
none_error: Option<ApiError>,
}
impl SqlLogMetadata {
fn captured(query_name: impl Into<Cow<'static, str>>) -> Self {
Self {
query_name: query_name.into(),
operation: SqlOperation::Other,
statement: Cow::Borrowed(""),
safe_parameters: BTreeMap::new(),
class_errors: BTreeMap::new(),
constraint_errors: BTreeMap::new(),
fallback_error: None,
zero_rows_error: None,
none_error: None,
}
}
fn with_safe_parameter(mut self, key: impl Into<String>, value: impl Display) -> Self {
let key = truncate_owned(key.into(), MAX_NAME_BYTES);
if !self.safe_parameters.contains_key(&key)
&& self.safe_parameters.len() >= MAX_DETAIL_FIELDS
{
return self;
}
self.safe_parameters.insert(
key,
Value::String(bounded_display(&value, MAX_DETAIL_STRING_BYTES)),
);
self
}
fn with_safe_json_parameter<T>(
mut self,
key: impl Into<String>,
value: T,
) -> Result<Self, serde_json::Error>
where
T: Serialize,
{
let key = truncate_owned(key.into(), MAX_NAME_BYTES);
if !self.safe_parameters.contains_key(&key)
&& self.safe_parameters.len() >= MAX_DETAIL_FIELDS
{
return Ok(self);
}
let value = match to_bounded_json_value(&value, MAX_DETAIL_JSON_BYTES)? {
BoundedJsonValue::Value(mut value) => {
bound_json_value(&mut value, 0);
value
}
BoundedJsonValue::TooLarge => Value::String("内容过大,已省略".into()),
};
self.safe_parameters.insert(key, value);
Ok(self)
}
fn on_error(mut self, class: SqlErrorClass, error: ApiError) -> Self {
self.class_errors.insert(class, error);
self
}
fn on_constraint(mut self, constraint: impl Into<String>, error: ApiError) -> Self {
if self.constraint_errors.len() < MAX_DETAIL_FIELDS {
self.constraint_errors
.insert(truncate_owned(constraint.into(), MAX_NAME_BYTES), error);
}
self
}
fn api_error(mut self, error: ApiError) -> Self {
self.fallback_error = Some(error);
self
}
fn not_found(self, message: impl Into<String>) -> Self {
self.on_error(SqlErrorClass::NotFound, ApiError::err_not_found(message))
}
fn unique_conflict(self, message: impl Into<String>) -> Self {
self.on_error(
SqlErrorClass::UniqueViolation,
ApiError::err_unique_index_conflict(message),
)
}
fn foreign_key_conflict(self, message: impl Into<String>) -> Self {
self.on_error(
SqlErrorClass::ForeignKeyViolation,
ApiError::err_foreign_key_conflict(message),
)
}
fn check_conflict(self, message: impl Into<String>) -> Self {
self.on_error(
SqlErrorClass::CheckViolation,
ApiError::err_constraint_conflict(message),
)
}
fn not_found_if_zero(mut self, message: impl Into<String>) -> Self {
self.zero_rows_error = Some(ApiError::err_not_found(message));
self
}
fn not_found_if_none(mut self, message: impl Into<String>) -> Self {
self.none_error = Some(ApiError::err_not_found(message));
self
}
fn take_api_error(
&mut self,
source: &sqlx::Error,
class: SqlErrorClass,
constraint: Option<&str>,
) -> ApiError {
if let Some(constraint) = constraint
&& let Some(error) = self.constraint_errors.remove(constraint)
{
return error;
}
self.class_errors
.remove(&class)
.or_else(|| self.fallback_error.take())
.unwrap_or_else(|| default_sqlx_api_error(source))
}
fn apply_captured_event(&mut self, event: &SqlxQueryEvent) {
if let Some(statement) = &event.statement {
if matches!(self.operation, SqlOperation::Other) {
self.operation = infer_sql_operation(statement);
}
self.statement = Cow::Owned(statement.clone());
}
}
fn sql_diagnostic(
&self,
source: &sqlx::Error,
code: Option<&str>,
constraint: Option<&str>,
) -> SqlDiagnostic {
let mut diagnostic = SqlDiagnostic::new(
self.query_name.as_ref(),
self.operation,
self.statement.as_ref(),
source,
);
diagnostic.safe_parameters = self.safe_parameters.clone();
diagnostic.error_code = code.map(ToOwned::to_owned);
diagnostic.constraint = constraint.map(ToOwned::to_owned);
diagnostic
}
fn business_diagnostic(&self, reason: &str) -> SqlDiagnostic {
let mut diagnostic = SqlDiagnostic::new(
self.query_name.as_ref(),
self.operation,
self.statement.as_ref(),
reason,
);
diagnostic.safe_parameters = self.safe_parameters.clone();
diagnostic
}
#[allow(clippy::too_many_arguments)]
fn into_execution(
self,
method: SqlExecutionMethod,
outcome: SqlExecutionOutcome,
elapsed: std::time::Duration,
rows_affected: Option<u64>,
rows_returned: Option<usize>,
error: Option<SqlExecutionError>,
api_error_code: Option<u32>,
) -> SqlExecution {
SqlExecution {
execution_id: 0,
query_name: bounded_display(self.query_name.as_ref(), MAX_NAME_BYTES),
operation: self.operation,
method,
statement: bounded_display(self.statement.as_ref(), MAX_STATEMENT_BYTES),
outcome,
elapsed_ms: elapsed.as_secs_f64() * 1_000.0,
rows_affected,
rows_returned,
safe_parameters: self.safe_parameters,
error,
api_error_code,
}
}
}
#[must_use = "需要调用 execute 或 fetch_* 执行查询"]
pub struct LoggedSql<Q> {
query: Q,
trace: SqlLogMetadata,
record_success: bool,
record_failure: bool,
}
impl<Q> LoggedSql<Q> {
fn new(query: Q, query_name: impl Into<Cow<'static, str>>) -> Self {
Self {
query,
trace: SqlLogMetadata::captured(query_name),
record_success: false,
record_failure: false,
}
}
pub fn logger_sql(mut self) -> Self {
self.record_success = true;
self.record_failure = true;
self
}
pub fn logger_err(mut self) -> Self {
self.record_failure = true;
self
}
pub fn query_name(mut self, query_name: impl Into<Cow<'static, str>>) -> Self {
self.trace.query_name = query_name.into();
self
}
pub const fn operation(mut self, operation: SqlOperation) -> Self {
self.trace.operation = operation;
self
}
pub fn api_err(mut self, error: ApiError) -> Self {
self.trace = self.trace.api_error(error);
self
}
pub fn api_err_for(mut self, class: SqlErrorClass, error: ApiError) -> Self {
self.trace = self.trace.on_error(class, error);
self
}
pub fn api_err_for_constraint(
mut self,
constraint: impl Into<String>,
error: ApiError,
) -> Self {
self.trace = self.trace.on_constraint(constraint, error);
self
}
pub fn not_found(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.not_found(message);
self
}
pub fn unique_conflict(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.unique_conflict(message);
self
}
pub fn foreign_key_conflict(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.foreign_key_conflict(message);
self
}
pub fn check_conflict(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.check_conflict(message);
self
}
pub fn not_found_if_zero(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.not_found_if_zero(message);
self
}
pub fn not_found_if_none(mut self, message: impl Into<String>) -> Self {
self.trace = self.trace.not_found_if_none(message);
self
}
pub fn with_safe_parameter(mut self, key: impl Into<String>, value: impl Display) -> Self {
self.trace = self.trace.with_safe_parameter(key, value);
self
}
pub fn with_safe_json_parameter<T>(
mut self,
key: impl Into<String>,
value: T,
) -> Result<Self, serde_json::Error>
where
T: Serialize,
{
self.trace = self.trace.with_safe_json_parameter(key, value)?;
Ok(self)
}
fn default_operation(&mut self, operation: SqlOperation) {
if matches!(self.trace.operation, SqlOperation::Other) {
self.trace.operation = operation;
}
}
}
pub trait SqlLoggerExt: Sized {
fn logger_sql(self, query_name: impl Into<Cow<'static, str>>) -> LoggedSql<Self> {
LoggedSql::new(self, query_name).logger_sql()
}
fn logger_err(self) -> LoggedSql<Self> {
LoggedSql::new(self, "sqlx.query").logger_err()
}
fn api_err(self, error: ApiError) -> LoggedSql<Self> {
LoggedSql::new(self, "sqlx.query")
.logger_err()
.api_err(error)
}
}
impl<'q, DB, A> SqlLoggerExt for sqlx::query::Query<'q, DB, A> where DB: sqlx::Database {}
impl<'q, DB, O, A> SqlLoggerExt for sqlx::query::QueryAs<'q, DB, O, A> where DB: sqlx::Database {}
impl<'q, DB, O, A> SqlLoggerExt for sqlx::query::QueryScalar<'q, DB, O, A> where DB: sqlx::Database {}
impl<'q, DB, F, A> SqlLoggerExt for sqlx::query::Map<'q, DB, F, A> where DB: sqlx::Database {}
struct SqlLogConfig {
trace: SqlLogMetadata,
record_success: bool,
record_failure: bool,
}
impl<Q> LoggedSql<Q> {
fn into_parts(self) -> (Q, SqlLogConfig) {
(
self.query,
SqlLogConfig {
trace: self.trace,
record_success: self.record_success,
record_failure: self.record_failure,
},
)
}
}
impl<'q, DB, A> LoggedSql<sqlx::query::Query<'q, DB, A>>
where
DB: sqlx::Database,
A: 'q + Send + sqlx::IntoArguments<DB>,
{
pub async fn execute<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<DB::QueryResult, ApiError>
where
'q: 'e,
A: 'e,
E: sqlx::Executor<'c, Database = DB>,
{
self.default_operation(SqlOperation::Other);
let (query, config) = self.into_parts();
run_logged_execute(query.execute(executor), config).await
}
pub async fn fetch_all<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<Vec<DB::Row>, ApiError>
where
'q: 'e,
A: 'e,
E: sqlx::Executor<'c, Database = DB>,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_all(query.fetch_all(executor), config).await
}
pub async fn fetch_optional<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<Option<DB::Row>, ApiError>
where
'q: 'e,
A: 'e,
E: sqlx::Executor<'c, Database = DB>,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_optional(query.fetch_optional(executor), config).await
}
pub async fn fetch_one<'e, 'c: 'e, E>(mut self, executor: E) -> Result<DB::Row, ApiError>
where
'q: 'e,
A: 'e,
E: sqlx::Executor<'c, Database = DB>,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_one(query.fetch_one(executor), config).await
}
}
impl<'q, DB, O, A> LoggedSql<sqlx::query::QueryAs<'q, DB, O, A>>
where
DB: sqlx::Database,
A: 'q + sqlx::IntoArguments<DB>,
O: Send + Unpin + for<'r> sqlx::FromRow<'r, DB::Row>,
{
pub async fn fetch_all<'e, 'c: 'e, E>(mut self, executor: E) -> Result<Vec<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
O: 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_all(query.fetch_all(executor), config).await
}
pub async fn fetch_optional<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<Option<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
O: 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_optional(query.fetch_optional(executor), config).await
}
pub async fn fetch_one<'e, 'c: 'e, E>(mut self, executor: E) -> Result<O, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
O: 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_one(query.fetch_one(executor), config).await
}
}
impl<'q, DB, O, A> LoggedSql<sqlx::query::QueryScalar<'q, DB, O, A>>
where
DB: sqlx::Database,
O: Send + Unpin,
A: 'q + sqlx::IntoArguments<DB>,
(O,): Send + Unpin + for<'r> sqlx::FromRow<'r, DB::Row>,
{
pub async fn fetch_all<'e, 'c: 'e, E>(mut self, executor: E) -> Result<Vec<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
(O,): 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_all(query.fetch_all(executor), config).await
}
pub async fn fetch_optional<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<Option<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
O: 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_optional(query.fetch_optional(executor), config).await
}
pub async fn fetch_one<'e, 'c: 'e, E>(mut self, executor: E) -> Result<O, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
O: 'e,
A: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_one(query.fetch_one(executor), config).await
}
}
impl<'q, DB, F, O, A> LoggedSql<sqlx::query::Map<'q, DB, F, A>>
where
DB: sqlx::Database,
F: FnMut(DB::Row) -> Result<O, sqlx::Error> + Send,
O: Send + Unpin,
A: 'q + Send + sqlx::IntoArguments<DB>,
{
pub async fn fetch_all<'e, 'c: 'e, E>(mut self, executor: E) -> Result<Vec<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
F: 'e,
O: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_all(query.fetch_all(executor), config).await
}
pub async fn fetch_optional<'e, 'c: 'e, E>(
mut self,
executor: E,
) -> Result<Option<O>, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
F: 'e,
O: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_optional(query.fetch_optional(executor), config).await
}
pub async fn fetch_one<'e, 'c: 'e, E>(mut self, executor: E) -> Result<O, ApiError>
where
'q: 'e,
E: 'e + sqlx::Executor<'c, Database = DB>,
DB: 'e,
F: 'e,
O: 'e,
{
self.default_operation(SqlOperation::Select);
let (query, config) = self.into_parts();
run_logged_fetch_one(query.fetch_one(executor), config).await
}
}
async fn await_logged<F>(
future: F,
capture_sql: bool,
) -> (F::Output, Option<SqlxQueryEvent>, Duration)
where
F: Future,
{
let started_at = Instant::now();
let (output, event) = if capture_sql {
capture_sqlx_query(future).await
} else {
(future.await, None)
};
(output, event, started_at.elapsed())
}
fn apply_captured_event(
config: &mut SqlLogConfig,
event: Option<SqlxQueryEvent>,
fallback_elapsed: Duration,
) -> (Duration, Option<u64>, Option<usize>) {
let Some(event) = event else {
return (fallback_elapsed, None, None);
};
let elapsed = event
.elapsed_secs
.map(Duration::from_secs_f64)
.unwrap_or(fallback_elapsed);
let rows_affected = event.rows_affected;
let rows_returned = event
.rows_returned
.and_then(|rows| usize::try_from(rows).ok());
config.trace.apply_captured_event(&event);
(elapsed, rows_affected, rows_returned)
}
async fn run_logged_execute<F, R>(future: F, mut config: SqlLogConfig) -> Result<R, ApiError>
where
F: Future<Output = Result<R, sqlx::Error>>,
{
let capture_sql = config.record_failure || config.trace.zero_rows_error.is_some();
let (result, event, fallback_elapsed) = await_logged(future, capture_sql).await;
let (elapsed, captured_rows_affected, captured_rows_returned) =
apply_captured_event(&mut config, event, fallback_elapsed);
match result {
Ok(result) => {
if captured_rows_affected == Some(0)
&& let Some(error) = config.trace.zero_rows_error.take()
{
return Err(finish_logged_business_failure(
config,
SqlExecutionMethod::Execute,
elapsed,
Some(0),
captured_rows_returned,
error,
"SQL 执行成功但影响行数为 0",
));
}
if config.record_success {
record_execution(
config.trace,
SqlExecutionMethod::Execute,
SqlExecutionOutcome::Success,
elapsed,
captured_rows_affected,
captured_rows_returned,
None,
None,
);
}
Ok(result)
}
Err(source) => Err(finish_logged_sqlx_failure(
config,
SqlExecutionMethod::Execute,
elapsed,
captured_rows_affected,
captured_rows_returned,
source,
)),
}
}
async fn run_logged_fetch_all<F, T>(
future: F,
mut config: SqlLogConfig,
) -> Result<Vec<T>, ApiError>
where
F: Future<Output = Result<Vec<T>, sqlx::Error>>,
{
let (result, event, fallback_elapsed) = await_logged(future, config.record_failure).await;
let (elapsed, rows_affected, captured_rows_returned) =
apply_captured_event(&mut config, event, fallback_elapsed);
match result {
Ok(rows) => {
if config.record_success {
record_execution(
config.trace,
SqlExecutionMethod::FetchAll,
SqlExecutionOutcome::Success,
elapsed,
rows_affected,
Some(rows.len()),
None,
None,
);
}
Ok(rows)
}
Err(source) => Err(finish_logged_sqlx_failure(
config,
SqlExecutionMethod::FetchAll,
elapsed,
rows_affected,
captured_rows_returned,
source,
)),
}
}
async fn run_logged_fetch_optional<F, T>(
future: F,
mut config: SqlLogConfig,
) -> Result<Option<T>, ApiError>
where
F: Future<Output = Result<Option<T>, sqlx::Error>>,
{
let (result, event, fallback_elapsed) = await_logged(future, config.record_failure).await;
let (elapsed, rows_affected, captured_rows_returned) =
apply_captured_event(&mut config, event, fallback_elapsed);
match result {
Ok(row) => {
let rows_returned = usize::from(row.is_some());
if row.is_none()
&& let Some(error) = config.trace.none_error.take()
{
return Err(finish_logged_business_failure(
config,
SqlExecutionMethod::FetchOptional,
elapsed,
rows_affected,
Some(0),
error,
"SQL 执行成功但没有返回数据",
));
}
if config.record_success {
record_execution(
config.trace,
SqlExecutionMethod::FetchOptional,
SqlExecutionOutcome::Success,
elapsed,
rows_affected,
Some(rows_returned),
None,
None,
);
}
Ok(row)
}
Err(source) => Err(finish_logged_sqlx_failure(
config,
SqlExecutionMethod::FetchOptional,
elapsed,
rows_affected,
captured_rows_returned,
source,
)),
}
}
async fn run_logged_fetch_one<F, T>(future: F, mut config: SqlLogConfig) -> Result<T, ApiError>
where
F: Future<Output = Result<T, sqlx::Error>>,
{
let (result, event, fallback_elapsed) = await_logged(future, config.record_failure).await;
let (elapsed, rows_affected, captured_rows_returned) =
apply_captured_event(&mut config, event, fallback_elapsed);
match result {
Ok(row) => {
if config.record_success {
record_execution(
config.trace,
SqlExecutionMethod::FetchOne,
SqlExecutionOutcome::Success,
elapsed,
rows_affected,
Some(1),
None,
None,
);
}
Ok(row)
}
Err(source) => Err(finish_logged_sqlx_failure(
config,
SqlExecutionMethod::FetchOne,
elapsed,
rows_affected,
captured_rows_returned,
source,
)),
}
}
fn finish_logged_sqlx_failure(
mut config: SqlLogConfig,
method: SqlExecutionMethod,
elapsed: Duration,
rows_affected: Option<u64>,
rows_returned: Option<usize>,
source: sqlx::Error,
) -> ApiError {
let class = SqlErrorClass::classify(&source);
let (code, constraint) = database_error_metadata(&source);
let diagnostic = config.record_failure.then(|| {
config
.trace
.sql_diagnostic(&source, code.as_deref(), constraint.as_deref())
});
let api_error = config
.trace
.take_api_error(&source, class, constraint.as_deref());
let api_error_code = api_error.code;
let error = config.record_failure.then(|| SqlExecutionError {
class: class.as_str().to_owned(),
message: bounded_display(&source, MAX_ERROR_BYTES),
code,
constraint,
});
let execution_id = config
.record_failure
.then(|| {
record_execution(
config.trace,
method,
SqlExecutionOutcome::Failure,
elapsed,
rows_affected,
rows_returned,
error,
Some(api_error_code),
)
})
.flatten();
if let Some(execution_id) = execution_id {
api_error.with_context("sql_execution_id", execution_id)
} else if let Some(diagnostic) = diagnostic {
api_error.with_source(&source).with_sql_error(diagnostic)
} else {
api_error
}
}
#[allow(clippy::too_many_arguments)]
fn finish_logged_business_failure(
config: SqlLogConfig,
method: SqlExecutionMethod,
elapsed: Duration,
rows_affected: Option<u64>,
rows_returned: Option<usize>,
api_error: ApiError,
reason: &'static str,
) -> ApiError {
let diagnostic = config
.record_failure
.then(|| config.trace.business_diagnostic(reason));
let api_error_code = api_error.code;
let error = config.record_failure.then(|| SqlExecutionError {
class: "not_found".to_owned(),
message: reason.to_owned(),
code: None,
constraint: None,
});
let execution_id = config
.record_failure
.then(|| {
record_execution(
config.trace,
method,
SqlExecutionOutcome::BusinessFailure,
elapsed,
rows_affected,
rows_returned,
error,
Some(api_error_code),
)
})
.flatten();
if let Some(execution_id) = execution_id {
api_error.with_context("sql_execution_id", execution_id)
} else if let Some(diagnostic) = diagnostic {
api_error.with_sql_error(diagnostic)
} else {
api_error
}
}
fn infer_sql_operation(statement: &str) -> SqlOperation {
match statement
.split_whitespace()
.next()
.unwrap_or_default()
.to_ascii_uppercase()
.as_str()
{
"SELECT" => SqlOperation::Select,
"INSERT" => SqlOperation::Insert,
"UPDATE" => SqlOperation::Update,
"DELETE" => SqlOperation::Delete,
_ => SqlOperation::Other,
}
}
pub(crate) fn record_default_sqlx_failure(
event: Option<SqlxQueryEvent>,
method: SqlExecutionMethod,
fallback_elapsed: Duration,
source: &sqlx::Error,
) {
let mut trace = SqlLogMetadata::captured("sqlx.query");
let (elapsed, rows_affected, rows_returned) = if let Some(event) = event {
let elapsed = event
.elapsed_secs
.map(Duration::from_secs_f64)
.unwrap_or(fallback_elapsed);
let rows_affected = event.rows_affected;
let rows_returned = event
.rows_returned
.and_then(|rows| usize::try_from(rows).ok());
trace.apply_captured_event(&event);
(elapsed, rows_affected, rows_returned)
} else {
(fallback_elapsed, None, None)
};
if matches!(trace.operation, SqlOperation::Other)
&& !matches!(method, SqlExecutionMethod::Execute)
{
trace.operation = SqlOperation::Select;
}
let class = SqlErrorClass::classify(source);
let (code, constraint) = database_error_metadata(source);
let api_error_code = default_sqlx_api_error(source).code;
record_execution(
trace,
method,
SqlExecutionOutcome::Failure,
elapsed,
rows_affected,
rows_returned,
Some(SqlExecutionError {
class: class.as_str().to_owned(),
message: bounded_display(source, MAX_ERROR_BYTES),
code,
constraint,
}),
Some(api_error_code),
);
}
#[allow(clippy::too_many_arguments)]
fn record_execution(
trace: SqlLogMetadata,
method: SqlExecutionMethod,
outcome: SqlExecutionOutcome,
elapsed: std::time::Duration,
rows_affected: Option<u64>,
rows_returned: Option<usize>,
error: Option<SqlExecutionError>,
api_error_code: Option<u32>,
) -> Option<u64> {
let context = RequestLogContext::try_current()?;
context.record_sql_execution(trace.into_execution(
method,
outcome,
elapsed,
rows_affected,
rows_returned,
error,
api_error_code,
))
}
fn database_error_metadata(error: &sqlx::Error) -> (Option<String>, Option<String>) {
let sqlx::Error::Database(error) = error else {
return (None, None);
};
(
error.code().map(Cow::into_owned),
error.constraint().map(ToOwned::to_owned),
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::observability::context::scope_request_log;
use tracing_subscriber::prelude::*;
fn captured_config(record_success: bool, record_failure: bool) -> SqlLogConfig {
SqlLogConfig {
trace: SqlLogMetadata::captured("student.list"),
record_success,
record_failure,
}
}
fn emit_sqlx_event(statement: &'static str, rows_returned: u64) {
tracing::event!(
target: "sqlx::query",
tracing::Level::DEBUG,
{
db.statement = statement,
rows_affected = 0_u64,
rows_returned = rows_returned,
elapsed_secs = 0.012_f64
},
"SELECT id FROM students"
);
}
#[test]
fn constraint_error_has_priority_over_class_error() {
let source = sqlx::Error::RowNotFound;
let mut trace = SqlLogMetadata::captured("user.create")
.unique_conflict("数据已存在")
.on_constraint(
"uk_users_email",
ApiError::err_unique_index_conflict("该邮箱已经注册"),
);
let error = trace.take_api_error(
&source,
SqlErrorClass::UniqueViolation,
Some("uk_users_email"),
);
assert_eq!(error.code, 409_001);
assert_eq!(error.msg, "该邮箱已经注册");
}
#[tokio::test(flavor = "current_thread")]
async fn new_logging_policies_capture_expected_executions() {
let subscriber = tracing_subscriber::registry()
.with(crate::observability::SqlxQueryLayer::new().with_capture_filter());
let _guard = tracing::subscriber::set_default(subscriber);
let context = RequestLogContext::new();
scope_request_log(context.clone(), async {
let rows = run_logged_fetch_all(
async {
emit_sqlx_event("SELECT id FROM students", 2);
Ok::<_, sqlx::Error>(vec![1_u64, 2])
},
captured_config(true, true),
)
.await
.unwrap();
assert_eq!(rows, vec![1, 2]);
run_logged_fetch_all(
async {
emit_sqlx_event("SELECT id FROM students", 1);
Ok::<_, sqlx::Error>(vec![1_u64])
},
captured_config(false, true),
)
.await
.unwrap();
assert_eq!(context.structured_snapshot().sql_executions.len(), 1);
let error = run_logged_fetch_one(
async {
emit_sqlx_event("SELECT id FROM students WHERE id = ?", 0);
Err::<u64, _>(sqlx::Error::RowNotFound)
},
captured_config(false, true),
)
.await
.unwrap_err();
assert_eq!(error.code, 404_000);
let _ = run_logged_fetch_one(
async {
emit_sqlx_event("SELECT id FROM students WHERE id = ? LIMIT 1", 0);
Err::<u64, _>(sqlx::Error::RowNotFound)
},
captured_config(true, true),
)
.await
.unwrap_err();
let mut custom_error_config = captured_config(false, false);
custom_error_config.trace = custom_error_config
.trace
.api_error(ApiError::err_database("自定义数据库错误"));
let error = run_logged_fetch_one(
async { Err::<u64, _>(sqlx::Error::RowNotFound) },
custom_error_config,
)
.await
.unwrap_err();
assert_eq!(error.msg, "自定义数据库错误");
})
.await;
let snapshot = context.structured_snapshot();
assert_eq!(snapshot.sql_executions.len(), 3);
assert_eq!(
snapshot.sql_executions[0].statement,
"SELECT id FROM students"
);
assert_eq!(snapshot.sql_executions[0].rows_returned, Some(2));
assert_eq!(
snapshot.sql_executions[0].outcome,
SqlExecutionOutcome::Success
);
assert!(snapshot.sql_executions[0].error.is_none());
for execution in &snapshot.sql_executions[1..] {
assert_eq!(execution.outcome, SqlExecutionOutcome::Failure);
assert!(execution.error.is_some());
}
}
}
}
#[cfg(any(feature = "connection-mysql", feature = "connection-postgres"))]
pub(crate) use sqlx_support::record_default_sqlx_failure;
#[cfg(any(feature = "connection-mysql", feature = "connection-postgres"))]
pub use sqlx_support::{LoggedSql, SqlLoggerExt};