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/database/calendar_dao.rs

@@ -46,23 +46,14 @@ pub struct InsertCalendarEvent {
 
 pub trait CalendarEventDao: Sync + Send {
     /// Store calendar event with optional embedding
-    fn store_event(
-        &mut self,
-        context: &opentelemetry::Context,
-        event: InsertCalendarEvent,
-    ) -> Result<CalendarEvent, DbError>;
+    fn store_event(&mut self, event: InsertCalendarEvent) -> Result<CalendarEvent, DbError>;
 
     /// Batch insert events (for import efficiency)
-    fn store_events_batch(
-        &mut self,
-        context: &opentelemetry::Context,
-        events: Vec<InsertCalendarEvent>,
-    ) -> Result<usize, DbError>;
+    fn store_events_batch(&mut self, events: Vec<InsertCalendarEvent>) -> Result<usize, DbError>;
 
     /// Find events in time range (PRIMARY query method)
     fn find_events_in_range(
         &mut self,
-        context: &opentelemetry::Context,
         start_ts: i64,
         end_ts: i64,
     ) -> Result<Vec<CalendarEvent>, DbError>;
@@ -70,7 +61,6 @@ pub trait CalendarEventDao: Sync + Send {
     /// Find semantically similar events (SECONDARY - requires embeddings)
     fn find_similar_events(
         &mut self,
-        context: &opentelemetry::Context,
         query_embedding: &[f32],
         limit: usize,
     ) -> Result<Vec<CalendarEvent>, DbError>;
@@ -79,7 +69,6 @@ pub trait CalendarEventDao: Sync + Send {
     /// "Events during photo timestamp ±N days, ranked by similarity to context"
     fn find_relevant_events_hybrid(
         &mut self,
-        context: &opentelemetry::Context,
         center_timestamp: i64,
         time_window_days: i64,
         query_embedding: Option<&[f32]>,
@@ -87,15 +76,10 @@ pub trait CalendarEventDao: Sync + Send {
     ) -> Result<Vec<CalendarEvent>, DbError>;
 
     /// Check if event exists (idempotency)
-    fn event_exists(
-        &mut self,
-        context: &opentelemetry::Context,
-        event_uid: &str,
-        start_time: i64,
-    ) -> Result<bool, DbError>;
+    fn event_exists(&mut self, event_uid: &str, start_time: i64) -> Result<bool, DbError>;
 
     /// Get count of events
-    fn get_event_count(&mut self, context: &opentelemetry::Context) -> Result<i64, DbError>;
+    fn get_event_count(&mut self) -> Result<i64, DbError>;
 }
 
 pub struct SqliteCalendarEventDao {
@@ -209,12 +193,8 @@ struct LastInsertRowId {
 }
 
 impl CalendarEventDao for SqliteCalendarEventDao {
-    fn store_event(
-        &mut self,
-        context: &opentelemetry::Context,
-        event: InsertCalendarEvent,
-    ) -> Result<CalendarEvent, DbError> {
-        trace_db_call(context, "insert", "store_event", |_span| {
+    fn store_event(&mut self, event: InsertCalendarEvent) -> Result<CalendarEvent, DbError> {
+        trace_db_call("insert", "store_event", |_span| {
             let mut conn = self
                 .connection
                 .lock()
@@ -278,12 +258,8 @@ impl CalendarEventDao for SqliteCalendarEventDao {
         .map_err(|e| DbError::log(DbErrorKind::InsertError, e))
     }
 
-    fn store_events_batch(
-        &mut self,
-        context: &opentelemetry::Context,
-        events: Vec<InsertCalendarEvent>,
-    ) -> Result<usize, DbError> {
-        trace_db_call(context, "insert", "store_events_batch", |_span| {
+    fn store_events_batch(&mut self, events: Vec<InsertCalendarEvent>) -> Result<usize, DbError> {
+        trace_db_call("insert", "store_events_batch", |_span| {
             let mut conn = self
                 .connection
                 .lock()
@@ -354,11 +330,10 @@ impl CalendarEventDao for SqliteCalendarEventDao {
 
     fn find_events_in_range(
         &mut self,
-        context: &opentelemetry::Context,
         start_ts: i64,
         end_ts: i64,
     ) -> Result<Vec<CalendarEvent>, DbError> {
-        trace_db_call(context, "query", "find_events_in_range", |_span| {
+        trace_db_call("query", "find_events_in_range", |_span| {
             let mut conn = self.connection.lock().expect("Unable to get CalendarEventDao");
 
             diesel::sql_query(
@@ -379,11 +354,10 @@ impl CalendarEventDao for SqliteCalendarEventDao {
 
     fn find_similar_events(
         &mut self,
-        context: &opentelemetry::Context,
         query_embedding: &[f32],
         limit: usize,
     ) -> Result<Vec<CalendarEvent>, DbError> {
-        trace_db_call(context, "query", "find_similar_events", |_span| {
+        trace_db_call("query", "find_similar_events", |_span| {
             let mut conn = self.connection.lock().expect("Unable to get CalendarEventDao");
 
             if query_embedding.len() != crate::ai::embedding_dim() {
@@ -436,13 +410,12 @@ impl CalendarEventDao for SqliteCalendarEventDao {
 
     fn find_relevant_events_hybrid(
         &mut self,
-        context: &opentelemetry::Context,
         center_timestamp: i64,
         time_window_days: i64,
         query_embedding: Option<&[f32]>,
         limit: usize,
     ) -> Result<Vec<CalendarEvent>, DbError> {
-        trace_db_call(context, "query", "find_relevant_events_hybrid", |_span| {
+        trace_db_call("query", "find_relevant_events_hybrid", |_span| {
             let window_seconds = time_window_days * 86400;
             let start_ts = center_timestamp - window_seconds;
             let end_ts = center_timestamp + window_seconds;
@@ -506,13 +479,8 @@ impl CalendarEventDao for SqliteCalendarEventDao {
         .map_err(|e| DbError::log(DbErrorKind::QueryError, e))
     }
 
-    fn event_exists(
-        &mut self,
-        context: &opentelemetry::Context,
-        event_uid: &str,
-        start_time: i64,
-    ) -> Result<bool, DbError> {
-        trace_db_call(context, "query", "event_exists", |_span| {
+    fn event_exists(&mut self, event_uid: &str, start_time: i64) -> Result<bool, DbError> {
+        trace_db_call("query", "event_exists", |_span| {
             let mut conn = self.connection.lock().expect("Unable to get CalendarEventDao");
 
             #[derive(QueryableByName)]
@@ -534,8 +502,8 @@ impl CalendarEventDao for SqliteCalendarEventDao {
         .map_err(|e| DbError::log(DbErrorKind::QueryError, e))
     }
 
-    fn get_event_count(&mut self, context: &opentelemetry::Context) -> Result<i64, DbError> {
-        trace_db_call(context, "query", "get_event_count", |_span| {
+    fn get_event_count(&mut self) -> Result<i64, DbError> {
+        trace_db_call("query", "get_event_count", |_span| {
             let mut conn = self
                 .connection
                 .lock()