Tracing: DAO layer + handler spans on tracing, drop all Context params (#141)

trace_db_call no longer takes an OpenTelemetry Context: it opens a
db.<query_type>.<operation> span (same name via otel.name, same
db.query_type / db.operation attrs) on the caller's ambient tracing span
and runs the DAO body inside it. The cx / ctx / context parameter is gone
from every DAO trait method, impl and call site, and from the helpers and
background drains that only threaded it.

The remaining request-handler spans (files, tags, faces, image, video,
favorites, duplicates, memories) move to #[instrument]; the
Context::current_with_span / with_remote_span_context plumbing is gone, as
is extract_context_from_request (the tracing-actix-web root span covers
it). otel::set_span_attributes replaces BoxedSpan::set_attributes.

Background-job raw spans (thumbnails, video actors) are left for #142.

tests/otel_db_spans.rs pins name, attributes, status and nesting (across
an instrumented spawn); otel_traceparent now uses an #[instrument]
handler. CLAUDE.md documents the tracing conventions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/otel_db_spans.rs

@@ -0,0 +1,100 @@
+//! Verifies the DAO-layer tracing migration (#141 / map #135).
+//!
+//! Every DAO method funnels through `otel::trace_db_call`, which no longer
+//! takes an OpenTelemetry `Context`: the `db.<query_type>.<operation>` span
+//! parents on the caller's ambient `tracing` span. Pinned here:
+//!
+//! 1. **Name + attributes.** The exported span keeps the pre-migration name
+//!    (`db.query.get_tags`) and `db.query_type` / `db.operation` attributes,
+//!    plus anything the closure records on the span it's handed.
+//! 2. **Nesting.** It is a child of the ambient span — including inside a
+//!    `tokio::spawn` that carries the parent via `.instrument`.
+//! 3. **Status.** `Ok` on success, `Error` with the message on failure.
+//!
+//! One process-global subscriber per test binary, so this file holds a
+//! single test.
+
+use opentelemetry::trace::{Status, TracerProvider};
+use opentelemetry::Value;
+use opentelemetry_sdk::trace::{InMemorySpanExporter, SdkTracerProvider, SpanData};
+use tracing::Instrument;
+use tracing_opentelemetry::OpenTelemetrySpanExt;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::registry::Registry;
+use tracing_subscriber::util::SubscriberInitExt;
+
+fn attr(span: &SpanData, key: &str) -> Option<Value> {
+    span.attributes
+        .iter()
+        .find(|kv| kv.key.as_str() == key)
+        .map(|kv| kv.value.clone())
+}
+
+fn find<'a>(spans: &'a [SpanData], name: &str) -> &'a SpanData {
+    spans
+        .iter()
+        .find(|s| s.name == name)
+        .unwrap_or_else(|| panic!("span {name} not exported"))
+}
+
+#[test]
+fn db_spans_nest_under_ambient_span() {
+    let exporter = InMemorySpanExporter::default();
+    let provider = SdkTracerProvider::builder()
+        .with_simple_exporter(exporter.clone())
+        .build();
+    Registry::default()
+        .with(tracing_opentelemetry::OpenTelemetryLayer::new(
+            provider.tracer("db-span-test"),
+        ))
+        .try_init()
+        .expect("global subscriber not yet set");
+
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .enable_all()
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        let handler = tracing::info_span!("test.handler");
+        tokio::spawn(
+            async {
+                let ok = image_api::otel::trace_db_call("query", "get_tags", |span| {
+                    span.set_attribute("path", "a/b.jpg");
+                    Ok(3)
+                });
+                assert_eq!(ok.unwrap(), 3);
+
+                let err: anyhow::Result<()> =
+                    image_api::otel::trace_db_call("delete", "remove_tag", |_span| {
+                        anyhow::bail!("no such tag")
+                    });
+                assert!(err.is_err());
+            }
+            .instrument(handler),
+        )
+        .await
+        .expect("spawned handler");
+    });
+    let _ = provider.force_flush();
+
+    let spans = exporter.get_finished_spans().unwrap();
+    let handler = find(&spans, "test.handler");
+    let get = find(&spans, "db.query.get_tags");
+    let del = find(&spans, "db.delete.remove_tag");
+
+    for (span, qt, op) in [(get, "query", "get_tags"), (del, "delete", "remove_tag")] {
+        assert_eq!(span.span_context.trace_id(), handler.span_context.trace_id());
+        assert_eq!(
+            span.parent_span_id,
+            handler.span_context.span_id(),
+            "{op}: db span must be a child of the ambient span"
+        );
+        assert_eq!(attr(span, "db.query_type"), Some(qt.into()));
+        assert_eq!(attr(span, "db.operation"), Some(op.into()));
+    }
+    assert_eq!(attr(get, "path"), Some("a/b.jpg".into()));
+    assert_eq!(get.status, Status::Ok);
+    assert_eq!(del.status, Status::error("no such tag"));
+}