Add SQLx operation tracing (#5223)

* wip: vendor sqlx-tracing

* (compiles) standardize pg types used

* more standardization

* general log message improvements

* wip: improve sqlx-tracing architecture

* unify sqlx::Executor type

* wip: try fix sqlx tracing

* wip: sqlx-tracing compiles

* so close

* it compiles

* fix ci

packages/sqlx-tracing/tests/common.rs

@@ -0,0 +1,47 @@
+use std::time::Duration;
+
+use opentelemetry::trace::{FutureExt, TraceContextExt, Tracer};
+
+pub async fn should_trace<'c, DB, E>(
+    name: &'static str,
+    system: &'static str,
+    observability: &opentelemetry_testing::ObservabilityContainer,
+    provider: &opentelemetry_testing::OpenTelemetryProvider,
+    executor: E,
+) where
+    DB: sqlx::Database,
+    E: sqlx::Executor<'c, Database = DB>,
+    for<'q> DB::Arguments<'q>: 'q + sqlx::IntoArguments<'q, DB>,
+    (i32,): Send + Unpin + for<'r> sqlx::FromRow<'r, DB::Row>,
+{
+    let scope = format!("should_{name}_{system}");
+    let tracer = opentelemetry::global::tracer(scope.clone());
+    let span = tracer.span_builder(name).start(&tracer);
+    let ctx = opentelemetry::Context::new().with_span(span);
+
+    let result: Option<i32> = sqlx::query_scalar("select 1")
+        .fetch_optional(executor)
+        .with_context(ctx)
+        .await
+        .unwrap();
+
+    assert_eq!(result, Some(1));
+
+    provider.flush();
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    let traces = observability.json_traces();
+    let scope_span = traces.find_scope_span(&scope).unwrap();
+    let entry = scope_span.first_span().unwrap();
+    assert_eq!(entry.name, name);
+    let next = traces
+        .find_child(&entry.span_id, "sqlx.fetch_optional")
+        .unwrap();
+    assert_eq!(next.string_attribute("db.system.name").unwrap(), system);
+    assert_eq!(next.string_attribute("db.query.text").unwrap(), "select 1");
+    assert_eq!(
+        next.int_attribute("db.response.returned_rows").unwrap(),
+        "1"
+    );
+}