use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
use std::time::Instant;
use futures_core::Stream;
use futures_core::stream::BoxStream;
use crate::record::{self, Analysis, Call, Failure, UNKNOWN};
#[cfg(feature = "sqlx-0.8")]
pub mod v0_8;
#[cfg(feature = "sqlx-0.9")]
pub mod v0_9;
fn system_of(name: &str) -> &'static str {
match name {
"PostgreSQL" => "postgresql",
"MySQL" => "mysql",
"SQLite" => "sqlite",
_ => "other_sql",
}
}
fn has_url(name: &str) -> bool {
matches!(name, "PostgreSQL" | "MySQL" | "SQLite")
}
#[derive(Debug)]
pub(crate) struct Target {
system: &'static str,
namespace: Option<String>,
server: Option<(String, u16)>,
pub(crate) pool_name: Arc<str>,
}
impl Target {
fn new(name: &str, url: Option<(Option<&str>, Option<u16>, &str)>) -> Self {
let system = system_of(name);
let (namespace, server) = match url {
Some((host, port, path)) if system != "sqlite" => {
let namespace = path.trim_start_matches('/');
let namespace = (!namespace.is_empty()).then(|| namespace.to_string());
let default_port = if system == "mysql" { 3306 } else { 5432 };
let server = host
.filter(|h| !h.is_empty())
.map(|h| (h.to_string(), port.unwrap_or(default_port)));
(namespace, server)
}
_ => (None, None),
};
let pool_name = crate::pool::default_name(
system,
namespace.as_deref(),
server.as_ref().map(|(a, p)| (a.as_str(), *p)),
);
Target {
system,
namespace,
server,
pool_name: pool_name.into(),
}
}
fn call<'a>(&'a self, analysis: &'a Analysis) -> Call<'a> {
Call {
system: self.system,
namespace: self.namespace.as_deref(),
server: self.server.as_ref().map(|(a, p)| (a.as_str(), *p)),
analysis,
}
}
fn with_pool_name(&self, name: &str) -> Self {
Target {
system: self.system,
namespace: self.namespace.clone(),
server: self.server.clone(),
pool_name: name.into(),
}
}
}
pub(crate) type Statement = Arc<Mutex<Option<Arc<Analysis>>>>;
fn statement(analysis: Option<Arc<Analysis>>) -> Statement {
Arc::new(Mutex::new(analysis))
}
pub(crate) struct Fail {
error_type: String,
code: Option<String>,
}
impl Fail {
fn new(code: Option<String>, kind: Option<&str>) -> Self {
let error_type = match (&code, kind) {
(Some(code), _) => code.clone(),
(None, Some(kind)) => format!("sqlx::Error::{kind}"),
(None, None) => "sqlx::Error".to_string(),
};
Fail { error_type, code }
}
}
pub(crate) struct QueryCall {
target: Arc<Target>,
span: tracing::Span,
started: Instant,
rows: u64,
statement: Statement,
done: bool,
}
impl QueryCall {
fn start(target: &Arc<Target>, statement: Statement) -> Self {
let span = record::open_span(
target.system,
target.namespace.as_deref(),
target.server.as_ref().map(|(a, p)| (a.as_str(), *p)),
);
QueryCall {
target: Arc::clone(target),
span,
started: Instant::now(),
rows: 0,
statement,
done: false,
}
}
fn finish(&mut self, failure: Option<Fail>) {
if std::mem::replace(&mut self.done, true) {
return;
}
let seconds = self.started.elapsed().as_secs_f64();
let analysis = self
.statement
.lock()
.unwrap_or_else(|e| e.into_inner())
.take();
let analysis = analysis.as_deref().unwrap_or(&UNKNOWN);
record::describe(&self.span, analysis);
let failure = failure.as_ref().map(|f| Failure {
error_type: &f.error_type,
status_code: f.code.as_deref(),
});
match &failure {
Some(failure) => failure.record(&self.span),
None => {
self.span.record("db.response.returned_rows", self.rows);
}
}
let _entered = self.span.enter();
self.target
.call(analysis)
.record_duration(seconds, failure.as_ref());
}
}
impl Drop for QueryCall {
fn drop(&mut self) {
self.finish(None);
}
}
pub(crate) struct Recorded<'e, T, E> {
inner: BoxStream<'e, Result<T, E>>,
call: QueryCall,
is_row: fn(&T) -> bool,
fail: fn(&E) -> Fail,
}
impl<'e, T, E> Recorded<'e, T, E> {
fn new(
inner: BoxStream<'e, Result<T, E>>,
call: QueryCall,
is_row: fn(&T) -> bool,
fail: fn(&E) -> Fail,
) -> Self {
Recorded {
inner,
call,
is_row,
fail,
}
}
}
impl<T, E> Stream for Recorded<'_, T, E> {
type Item = Result<T, E>;
fn poll_next(self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
let span = this.call.span.clone();
let _entered = span.enter();
let poll = this.inner.as_mut().poll_next(cx);
match &poll {
Poll::Ready(Some(Ok(item))) if (this.is_row)(item) => this.call.rows += 1,
Poll::Ready(Some(Ok(_))) | Poll::Pending => {}
Poll::Ready(Some(Err(error))) => this.call.finish(Some((this.fail)(error))),
Poll::Ready(None) => this.call.finish(None),
}
poll
}
}
async fn record_one<R, E>(
mut call: QueryCall,
operation: impl std::future::Future<Output = Result<R, E>>,
rows: fn(&R) -> u64,
fail: fn(&E) -> Fail,
) -> Result<R, E> {
use tracing::Instrument;
let result = operation.instrument(call.span.clone()).await;
match &result {
Ok(value) => {
call.rows = rows(value);
call.finish(None);
}
Err(error) => call.finish(Some(fail(error))),
}
result
}