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>

src/ai/insight_chat.rs

@@ -154,15 +154,14 @@ impl InsightChatService {
         branch_id: Option<u64>,
     ) -> Result<HistoryView> {
         let normalized = normalize_path(file_path);
-        let cx = opentelemetry::Context::new();
         let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
         let insight = match dao
-            .get_current_insight_for_library(&cx, library_id, &normalized)
+            .get_current_insight_for_library(library_id, &normalized)
             .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
         {
             Some(i) => i,
             None => dao
-                .get_insight(&cx, &normalized)
+                .get_insight(&normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
                 .ok_or_else(|| anyhow!("no insight found for path"))?,
         };
@@ -238,9 +237,8 @@ impl InsightChatService {
 
         // 2. Load the current insight + history.
         let insight = {
-            let cx = opentelemetry::Context::new();
             let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
-            dao.get_current_insight_for_library(&cx, req.library_id, &normalized)
+            dao.get_current_insight_for_library(req.library_id, &normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
                 .ok_or_else(|| anyhow!("no insight found for path"))?
         };
@@ -363,7 +361,6 @@ impl InsightChatService {
         //    Each LLM / tool await runs inside `loop_span` so their spans
         //    nest under it.
         let loop_span = tracing::info_span!("ai.chat.loop");
-        let loop_cx = loop_span.context();
         let mut tool_calls_made = 0usize;
         let mut iterations_used = 0usize;
         let mut last_prompt_eval_count: Option<i32> = None;
@@ -414,7 +411,6 @@ impl InsightChatService {
                             &normalized,
                             req.user_id,
                             &active_persona,
-                            &loop_cx,
                         )
                         .instrument(loop_span.clone())
                         .await;
@@ -533,18 +529,16 @@ impl InsightChatService {
             };
             let dao = self.insight_dao.clone();
             let stored = retry_with_backoff("store_insight", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.store_insight(&cx, new_row.clone())
+                d.store_insight(new_row.clone())
             })
             .map_err(|e| anyhow!("failed to store amended insight: {:?}", e))?;
             amended_insight_id = Some(stored.id);
         } else {
             let dao = self.insight_dao.clone();
             let rows = retry_with_backoff("update_training_messages", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.update_training_messages(&cx, req.library_id, &normalized, &json)
+                d.update_training_messages(req.library_id, &normalized, &json)
             })
             .map_err(|e| anyhow!("failed to persist chat history: {:?}", e))?;
             if rows == 0 {
@@ -602,9 +596,8 @@ impl InsightChatService {
         let _guard = entry_lock.lock().await;
 
         let insight = {
-            let cx = opentelemetry::Context::new();
             let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
-            dao.get_current_insight_for_library(&cx, library_id, &normalized)
+            dao.get_current_insight_for_library(library_id, &normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
                 .ok_or_else(|| anyhow!("no insight found for path"))?
         };
@@ -639,9 +632,8 @@ impl InsightChatService {
 
         let dao = self.insight_dao.clone();
         let rows = retry_with_backoff("update_training_messages", 3, || {
-            let cx = opentelemetry::Context::new();
             let mut d = dao.lock().expect("Unable to lock InsightDao");
-            d.update_training_messages(&cx, library_id, &normalized, &json)
+            d.update_training_messages(library_id, &normalized, &json)
         })
         .map_err(|e| anyhow!("failed to persist rewound history: {:?}", e))?;
         if rows == 0 {
@@ -677,9 +669,8 @@ impl InsightChatService {
         let _guard = entry_lock.lock().await;
 
         let insight = {
-            let cx = opentelemetry::Context::new();
             let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
-            dao.get_current_insight_for_library(&cx, library_id, &normalized)
+            dao.get_current_insight_for_library(library_id, &normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
                 .ok_or_else(|| anyhow!("no insight found for path"))?
         };
@@ -710,9 +701,8 @@ impl InsightChatService {
 
         let dao = self.insight_dao.clone();
         let rows = retry_with_backoff("update_training_messages", 3, || {
-            let cx = opentelemetry::Context::new();
             let mut d = dao.lock().expect("Unable to lock InsightDao");
-            d.update_training_messages(&cx, library_id, &normalized, &json)
+            d.update_training_messages(library_id, &normalized, &json)
         })
         .map_err(|e| anyhow!("failed to persist branch switch: {:?}", e))?;
         if rows == 0 {
@@ -742,10 +732,9 @@ impl InsightChatService {
         viewing_leaf: Option<u64>,
     ) -> Result<(Vec<BranchLeafInfo>, u64)> {
         let normalized = normalize_path(file_path);
-        let cx = opentelemetry::Context::new();
         let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
         let insight = dao
-            .get_current_insight_for_library(&cx, library_id, &normalized)
+            .get_current_insight_for_library(library_id, &normalized)
             .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
             .ok_or_else(|| anyhow!("no insight found for path"))?;
 
@@ -930,9 +919,8 @@ impl InsightChatService {
 
         // Look up existing insight scoped to this turn's library_id.
         let existing_insight = {
-            let cx = opentelemetry::Context::new();
             let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
-            dao.get_current_insight_for_library(&cx, req.library_id, &normalized)
+            dao.get_current_insight_for_library(req.library_id, &normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
         };
 
@@ -1129,18 +1117,16 @@ impl InsightChatService {
             };
             let dao = self.insight_dao.clone();
             let stored = retry_with_backoff("store_insight", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.store_insight(&cx, new_row.clone())
+                d.store_insight(new_row.clone())
             })
             .map_err(|e| anyhow!("failed to store amended insight: {:?}", e))?;
             amended_insight_id = Some(stored.id);
         } else {
             let dao = self.insight_dao.clone();
             let rows = retry_with_backoff("update_training_messages", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.update_training_messages(&cx, req.library_id, &normalized, &json)
+                d.update_training_messages(req.library_id, &normalized, &json)
             })
             .map_err(|e| anyhow!("failed to persist chat history: {:?}", e))?;
             if rows == 0 {
@@ -1327,9 +1313,8 @@ impl InsightChatService {
         };
         let dao = self.insight_dao.clone();
         let stored = retry_with_backoff("store_insight", 3, || {
-            let cx = opentelemetry::Context::new();
             let mut d = dao.lock().expect("Unable to lock InsightDao");
-            d.store_insight(&cx, new_row.clone())
+            d.store_insight(new_row.clone())
         })
         .map_err(|e| anyhow!("failed to store bootstrap insight: {:?}", e))?;
 
@@ -1417,9 +1402,8 @@ impl InsightChatService {
         // library bootstraps cleanly, even when another library has
         // an insight for the same rel_path.
         let existing_insight = {
-            let db_cx = opentelemetry::Context::new();
             let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
-            dao.get_current_insight_for_library(&db_cx, req.library_id, &normalized)
+            dao.get_current_insight_for_library(req.library_id, &normalized)
                 .map_err(|e| anyhow!("failed to load insight: {:?}", e))?
         };
 
@@ -1595,18 +1579,16 @@ impl InsightChatService {
             };
             let dao = self.insight_dao.clone();
             let stored = retry_with_backoff("store_insight", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.store_insight(&cx, new_row.clone())
+                d.store_insight(new_row.clone())
             })
             .map_err(|e| anyhow!("failed to store amended insight: {:?}", e))?;
             amended_insight_id = Some(stored.id);
         } else {
             let dao = self.insight_dao.clone();
             let rows = retry_with_backoff("update_training_messages", 3, || {
-                let cx = opentelemetry::Context::new();
                 let mut d = dao.lock().expect("Unable to lock InsightDao");
-                d.update_training_messages(&cx, req.library_id, &normalized, &json)
+                d.update_training_messages(req.library_id, &normalized, &json)
             })
             .map_err(|e| anyhow!("failed to persist chat history: {:?}", e))?;
             if rows == 0 {
@@ -1810,9 +1792,8 @@ impl InsightChatService {
         };
         let dao = self.insight_dao.clone();
         let stored = retry_with_backoff("store_insight", 3, || {
-            let cx = opentelemetry::Context::new();
             let mut d = dao.lock().expect("Unable to lock InsightDao");
-            d.store_insight(&cx, new_row.clone())
+            d.store_insight(new_row.clone())
         })
         .map_err(|e| anyhow!("failed to store bootstrap insight: {:?}", e))?;
 
@@ -1920,7 +1901,6 @@ impl InsightChatService {
                             arguments: tool_call.function.arguments.clone(),
                         })
                         .await;
-                    let cx = opentelemetry::Context::new();
                     let result = self
                         .generator
                         .execute_tool(
@@ -1931,7 +1911,6 @@ impl InsightChatService {
                             normalized,
                             user_id,
                             active_persona,
-                            &cx,
                         )
                         .await;
                     let (result_preview, result_truncated) = truncate_tool_result(&result);
@@ -2421,7 +2400,6 @@ pub async fn run_streaming_agentic_loop_with_entry(
                         arguments: tool_call.function.arguments.clone(),
                     })
                     .await;
-                let cx = opentelemetry::Context::new();
                 let result = generator
                     .execute_tool(
                         &tool_call.function.name,
@@ -2431,7 +2409,6 @@ pub async fn run_streaming_agentic_loop_with_entry(
                         normalized,
                         user_id,
                         active_persona,
-                        &cx,
                     )
                     .await;
                 let (result_preview, result_truncated) = truncate_tool_result(&result);