more slogggggggg

pkg/appview/db/device_store.go

···
 	"database/sql"
 	"encoding/base64"
 	"fmt"
+	"log/slog"
 	"time"
 
 	"github.com/google/uuid"
···
 		return nil, false
 	}
 	if err != nil {
-		fmt.Printf("Warning: Failed to query pending auth: %v\n", err)
+		slog.Warn("Failed to query pending auth", "component", "device_store", "error", err)
 		return nil, false
 	}
 
···
 		return nil, false
 	}
 	if err != nil {
-		fmt.Printf("Warning: Failed to query pending auth: %v\n", err)
+		slog.Warn("Failed to query pending auth", "component", "device_store", "error", err)
 		return nil, false
 	}
 
···
 	`)
 
 	if err != nil {
-		fmt.Printf("Warning: Failed to cleanup expired pending auths: %v\n", err)
+		slog.Warn("Failed to cleanup expired pending auths", "component", "device_store", "error", err)
 		return
 	}
 
 	deleted, _ := result.RowsAffected()
 	if deleted > 0 {
-		fmt.Printf("Cleaned up %d expired pending device auths\n", deleted)
+		slog.Info("Cleaned up expired pending device auths", "count", deleted)
 	}
 }
 
···
 
 	deleted, _ := result.RowsAffected()
 	if deleted > 0 {
-		fmt.Printf("Cleaned up %d expired pending device auths\n", deleted)
+		slog.Info("Cleaned up expired pending device auths", "count", deleted)
 	}
 
 	return nil

pkg/appview/db/oauth_store.go

···
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/auth/oauth"
···
 
 	deleted, _ := result.RowsAffected()
 	if deleted > 0 {
-		fmt.Printf("Deleted %d OAuth session(s) for DID %s\n", deleted, did)
+		slog.Info("Deleted OAuth sessions for DID", "count", deleted, "did", did)
 	}
 
 	return nil
···
 
 	deleted, _ := result.RowsAffected()
 	if deleted > 0 {
-		fmt.Printf("Cleaned up %d old OAuth sessions (older than %v)\n", deleted, olderThan)
+		slog.Info("Cleaned up old OAuth sessions", "count", deleted, "older_than", olderThan)
 	}
 
 	return nil
···
 
 	deleted, _ := result.RowsAffected()
 	if deleted > 0 {
-		fmt.Printf("Cleaned up %d expired auth requests\n", deleted)
+		slog.Info("Cleaned up expired auth requests", "count", deleted)
 	}
 
 	return nil
···
 	for rows.Next() {
 		var sessionKey, accountDID, sessionID, sessionDataJSON string
 		if err := rows.Scan(&sessionKey, &accountDID, &sessionID, &sessionDataJSON); err != nil {
-			fmt.Printf("WARNING [oauth/store]: Failed to scan session row: %v\n", err)
+			slog.Warn("Failed to scan session row", "component", "oauth/store", "error", err)
 			continue
 		}
 
 		// Parse session data
 		var sessionData oauth.ClientSessionData
 		if err := json.Unmarshal([]byte(sessionDataJSON), &sessionData); err != nil {
-			fmt.Printf("WARNING [oauth/store]: Failed to parse session data for %s: %v\n", sessionKey, err)
+			slog.Warn("Failed to parse session data", "component", "oauth/store", "session_key", sessionKey, "error", err)
 			// Delete malformed sessions
 			sessionsToDelete = append(sessionsToDelete, sessionKey)
 			continue
···
 				DELETE FROM oauth_sessions WHERE session_key = ?
 			`, key)
 			if err != nil {
-				fmt.Printf("WARNING [oauth/store]: Failed to delete session %s: %v\n", key, err)
+				slog.Warn("Failed to delete session", "component", "oauth/store", "session_key", key, "error", err)
 			}
 		}
-		fmt.Printf("Invalidated %d OAuth session(s) with mismatched scopes\n", len(sessionsToDelete))
+		slog.Info("Invalidated OAuth sessions with mismatched scopes", "count", len(sessionsToDelete))
 	}
 
 	return len(sessionsToDelete), nil

pkg/appview/handlers/device.go

···
 	"encoding/json"
 	"fmt"
 	"html/template"
+	"log/slog"
 	"net/http"
 	"net/url"
 	"strings"
···
 	// Approve the device
 	_, err := h.Store.ApprovePending(req.UserCode, sess.DID, sess.Handle)
 	if err != nil {
-		fmt.Printf("ERROR [device/approve]: Failed to approve: %v\n", err)
+		slog.Error("Failed to approve device", "component", "device/approve", "error", err)
 		http.Error(w, fmt.Sprintf("failed to approve: %v", err), http.StatusInternalServerError)
 		return
 	}

pkg/appview/jetstream/backfill.go

···
 
 	// First, query and cache the default hold's captain record
 	if b.defaultHoldDID != "" {
-		slog.Info("Backfill: Querying default hold captain record: %s\n", b.defaultHoldDID)
+		slog.Info("Backfill querying default hold captain record", "hold_did", b.defaultHoldDID)
 		if err := b.queryCaptainRecord(ctx, b.defaultHoldDID); err != nil {
-			slog.Warn("Backfill: Failed to query default hold captain record: %v\n", err)
+			slog.Warn("Backfill failed to query default hold captain record", "error", err)
 			// Don't fail the whole backfill - just warn
 		}
 	}
···
 	}
 
 	for _, collection := range collections {
-		slog.Info("Backfill: Processing collection: %s\n", collection)
+		slog.Info("Backfill processing collection", "collection", collection)
 
 		if err := b.backfillCollection(ctx, collection); err != nil {
 			return fmt.Errorf("failed to backfill collection %s: %w", collection, err)
 		}
 
-		slog.Info("Backfill: Completed collection: %s\n", collection)
+		slog.Info("Backfill completed collection", "collection", collection)
 	}
 
 	slog.Info("Backfill: All collections completed!")
···
 			return fmt.Errorf("failed to list repos: %w", err)
 		}
 
-		slog.Info("Backfill: Found %d repos with %s (cursor: %s)\n", len(result.Repos), collection, repoCursor)
+		slog.Info("Backfill found repos with collection", "count", len(result.Repos), "collection", collection, "cursor", repoCursor)
 
 		// Process each repo (DID)
 		for _, repo := range result.Repos {
 			recordCount, err := b.backfillRepo(ctx, repo.DID, collection)
 			if err != nil {
-				slog.Warn("Backfill: Failed to backfill repo %s: %v\n", repo.DID, err)
+				slog.Warn("Backfill failed to backfill repo", "did", repo.DID, "error", err)
 				continue
 			}
 
···
 			processedRecords += recordCount
 
 			if processedRepos%10 == 0 {
-				slog.Info("Backfill: Progress - %d repos, %d records\n", processedRepos, processedRecords)
+				slog.Info("Backfill progress", "repos", processedRepos, "records", processedRecords)
 			}
 		}
 
···
 		repoCursor = result.Cursor
 	}
 
-	slog.Info("Backfill: Collection %s complete - %d repos, %d records\n", collection, processedRepos, processedRecords)
+	slog.Info("Backfill collection complete", "collection", collection, "repos", processedRepos, "records", processedRecords)
 	return nil
 }
 
···
 			}
 
 			if err := b.processRecord(ctx, did, collection, &record); err != nil {
-				slog.Warn("Backfill: Failed to process record %s: %v\n", record.URI, err)
+				slog.Warn("Backfill failed to process record", "uri", record.URI, "error", err)
 				continue
 			}
 			recordCount++
···
 
 	// Reconcile deletions - remove records from DB that no longer exist on PDS
 	if err := b.reconcileDeletions(did, collection, foundManifestDigests, foundTags, foundStars); err != nil {
-		slog.Warn("Backfill: Failed to reconcile deletions for %s: %v\n", did, err)
+		slog.Warn("Backfill failed to reconcile deletions", "did", did, "error", err)
 	}
 
 	// After processing manifests, clean up orphaned tags (tags pointing to non-existent manifests)
 	if collection == atproto.ManifestCollection {
 		if err := db.CleanupOrphanedTags(b.db, did); err != nil {
-			slog.Warn("Backfill: Failed to cleanup orphaned tags for %s: %v\n", did, err)
+			slog.Warn("Backfill failed to cleanup orphaned tags", "did", did, "error", err)
 		}
 
 		// Reconcile annotations - ensure they come from newest manifest per repository
 		// This fixes out-of-order backfill where older manifests can overwrite newer annotations
 		if err := b.reconcileAnnotations(ctx, did, pdsClient); err != nil {
-			slog.Warn("Backfill: Failed to reconcile annotations for %s: %v\n", did, err)
+			slog.Warn("Backfill failed to reconcile annotations", "did", did, "error", err)
 		}
 	}
 
···
 		// Log deletions
 		deleted := len(dbDigests) - len(foundManifestDigests)
 		if deleted > 0 {
-			slog.Info("Backfill: Deleted %d orphaned manifests for %s\n", deleted, did)
+			slog.Info("Backfill deleted orphaned manifests", "count", deleted, "did", did)
 		}
 
 	case atproto.TagCollection:
···
 		// Log deletions
 		deleted := len(dbTags) - len(foundTags)
 		if deleted > 0 {
-			slog.Info("Backfill: Deleted %d orphaned tags for %s\n", deleted, did)
+			slog.Info("Backfill deleted orphaned tags", "count", deleted, "did", did)
 		}
 
 	case atproto.StarCollection:
···
 			// Suppress warning for external holds in test mode
 			return nil
 		}
-		fmt.Printf("WARNING [backfill]: Failed to query captain record for hold %s: %v\n", holdDID, err)
+		slog.Warn("Backfill failed to query captain record for hold", "hold_did", holdDID, "error", err)
 		// Don't fail the whole backfill - just skip this hold
 		return nil
 	}
···
 
 		// Retry on connection errors (hold service might still be starting)
 		if attempt < maxRetries && strings.Contains(err.Error(), "connection refused") {
-			slog.Info("Backfill: Hold not ready (attempt %d/%d), retrying in 2s...\n", attempt, maxRetries)
+			slog.Info("Backfill hold not ready, retrying", "attempt", attempt, "max_retries", maxRetries)
 			time.Sleep(2 * time.Second)
 			continue
 		}
···
 		return fmt.Errorf("failed to cache captain record: %w", err)
 	}
 
-	slog.Info("Backfill: Cached captain record for hold %s (owner: %s)\n", holdDID, captainRecord.OwnerDID)
+	slog.Info("Backfill cached captain record for hold", "hold_did", holdDID, "owner_did", captainRecord.OwnerDID)
 	return nil
 }
 
···
 		// Find newest manifest for this repository
 		newestManifest, err := db.GetNewestManifestForRepo(b.db, did, repo)
 		if err != nil {
-			fmt.Printf("WARNING [backfill]: Failed to get newest manifest for %s/%s: %v\n", did, repo, err)
+			slog.Warn("Backfill failed to get newest manifest for repo", "did", did, "repository", repo, "error", err)
 			continue // Skip on error
 		}
 
···
 		rkey := strings.TrimPrefix(newestManifest.Digest, "sha256:")
 		record, err := pdsClient.GetRecord(ctx, atproto.ManifestCollection, rkey)
 		if err != nil {
-			fmt.Printf("WARNING [backfill]: Failed to fetch manifest record for %s/%s: %v\n", did, repo, err)
+			slog.Warn("Backfill failed to fetch manifest record for repo", "did", did, "repository", repo, "error", err)
 			continue // Skip on error
 		}
 
 		// Parse manifest record
 		var manifestRecord atproto.ManifestRecord
 		if err := json.Unmarshal(record.Value, &manifestRecord); err != nil {
-			fmt.Printf("WARNING [backfill]: Failed to parse manifest record for %s/%s: %v\n", did, repo, err)
+			slog.Warn("Backfill failed to parse manifest record for repo", "did", did, "repository", repo, "error", err)
 			continue
 		}
 
···
 			if hasData {
 				err = db.UpsertRepositoryAnnotations(b.db, did, repo, manifestRecord.Annotations)
 				if err != nil {
-					fmt.Printf("WARNING [backfill]: Failed to reconcile annotations for %s/%s: %v\n", did, repo, err)
+					slog.Warn("Backfill failed to reconcile annotations for repo", "did", did, "repository", repo, "error", err)
 				} else {
-					slog.Info("Backfill: Reconciled annotations for %s/%s from newest manifest %s\n", did, repo, newestManifest.Digest)
+					slog.Info("Backfill reconciled annotations for repo from newest manifest", "did", did, "repository", repo, "digest", newestManifest.Digest)
 				}
 			}
 		}

pkg/appview/jetstream/worker.go

···
 		// Calculate lag (cursor is in microseconds)
 		now := time.Now().UnixMicro()
 		lagSeconds := float64(now-w.startCursor) / 1_000_000.0
-		slog.Info("Jetstream: Starting from cursor %d (%.1f seconds behind live)\n", w.startCursor, lagSeconds)
+		slog.Info("Jetstream starting from cursor", "cursor", w.startCursor, "lag_seconds", lagSeconds)
 	}
 
 	// Disable compression for now to debug
 	// q.Set("compress", "true")
 	u.RawQuery = q.Encode()
 
-	fmt.Printf("Connecting to Jetstream: %s\n", u.String())
+	slog.Info("Connecting to Jetstream", "url", u.String())
 
 	// Connect to Jetstream
 	conn, _, err := websocket.DefaultDialer.DialContext(ctx, u.String(), nil)
···
 
 				// If no pong for 60 seconds, connection is likely dead
 				if timeSinceLastPong > 60*time.Second {
-					slog.Info("Jetstream: No pong received for %s (sent %d pings, got %d pongs), closing connection\n",
-						timeSinceLastPong, pingsTotal, pongsTotal)
+					slog.Info("Jetstream no pong received, closing connection", "time_since_last_pong", timeSinceLastPong, "pings_sent", pingsTotal, "pongs_received", pongsTotal)
 					conn.Close()
 					return
 				}
···
 				// Send ping with write deadline
 				conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
-					slog.Info("Jetstream: Failed to send ping: %v\n", err)
+					slog.Warn("Jetstream failed to send ping", "error", err)
 					conn.Close()
 					return
 				}
···
 			return ctx.Err()
 		case <-heartbeatTicker.C:
 			elapsed := time.Since(lastHeartbeat)
-			slog.Info("Jetstream: Alive (processed %d events in last %.0fs)\n", eventCount, elapsed.Seconds())
+			slog.Info("Jetstream alive", "events_processed", eventCount, "elapsed_seconds", elapsed.Seconds())
 			eventCount = 0
 			lastHeartbeat = time.Now()
 		default:
···
 				}
 
 				// Log detailed context about the failure
-				slog.Info("Jetstream: Connection closed after %s\n", connDuration)
-				fmt.Printf("  - Events in last 30s: %d\n", eventCount)
-				fmt.Printf("  - Time since last event: %s\n", timeSinceLastEvent)
-				fmt.Printf("  - Ping/Pong: %d/%d (%.1f%% success)\n", pongsTotal, pingsTotal, pongRate)
-				fmt.Printf("  - Last pong: %s ago\n", timeSinceLastPong)
-				fmt.Printf("  - Error: %v\n", err)
-				fmt.Printf("  - Diagnosis: %s\n", diagnosis)
+				slog.Info("Jetstream connection closed", "duration", connDuration, "events_in_last_30s", eventCount, "time_since_last_event", timeSinceLastEvent, "pongs_received", pongsTotal, "pings_sent", pingsTotal, "pong_rate_pct", pongRate, "time_since_last_pong", timeSinceLastPong, "error", err, "diagnosis", diagnosis)
 
 				return fmt.Errorf("failed to read message: %w", err)
 			}
···
 			_ = decoder // Keep decoder to avoid unused variable error
 
 			if err := w.processMessage(message); err != nil {
-				fmt.Printf("ERROR processing message: %v\n", err)
+				slog.Error("ERROR processing message", "error", err)
 				// Continue processing other messages
 			} else {
 				eventCount++
···
 
 	// Debug: log first few collections we see to understand what's coming through
 	if w.debugCollectionCount < 5 {
-		fmt.Printf("Jetstream DEBUG: Received collection=%s, did=%s\n", commit.Collection, commit.DID)
+		slog.Debug("Jetstream received collection", "collection", commit.Collection, "did", commit.DID)
 		w.debugCollectionCount++
 	}
 
 	// Process based on collection
 	switch commit.Collection {
 	case atproto.ManifestCollection:
-		slog.Info("Jetstream: Processing manifest event: did=%s, operation=%s, rkey=%s\n",
-			commit.DID, commit.Operation, commit.RKey)
+		slog.Info("Jetstream processing manifest event", "did", commit.DID, "operation", commit.Operation, "rkey", commit.RKey)
 		return w.processManifest(commit)
 	case atproto.TagCollection:
-		slog.Info("Jetstream: Processing tag event: did=%s, operation=%s, rkey=%s\n",
-			commit.DID, commit.Operation, commit.RKey)
+		slog.Info("Jetstream processing tag event", "did", commit.DID, "operation", commit.Operation, "rkey", commit.RKey)
 		return w.processTag(commit)
 	case atproto.StarCollection:
-		slog.Info("Jetstream: Processing star event: did=%s, operation=%s, rkey=%s\n",
-			commit.DID, commit.Operation, commit.RKey)
+		slog.Info("Jetstream processing star event", "did", commit.DID, "operation", commit.Operation, "rkey", commit.RKey)
 		return w.processStar(commit)
 	default:
 		// Ignore other collections
···
 	if commit.Operation == "delete" {
 		// Delete tag - decode rkey back to repository and tag
 		repo, tag := atproto.RKeyToRepositoryTag(commit.RKey)
-		slog.Info("Jetstream: Deleting tag: did=%s, repository=%s, tag=%s (from rkey=%s)\n",
-			commit.DID, repo, tag, commit.RKey)
+		slog.Info("Jetstream deleting tag", "did", commit.DID, "repository", repo, "tag", tag, "rkey", commit.RKey)
 		if err := db.DeleteTag(w.db, commit.DID, repo, tag); err != nil {
-			slog.Info("Jetstream: ERROR deleting tag: %v\n", err)
+			slog.Error("Jetstream ERROR deleting tag", "error", err)
 			return err
 		}
-		slog.Info("Jetstream: Successfully deleted tag: did=%s, repository=%s, tag=%s\n",
-			commit.DID, repo, tag)
+		slog.Info("Jetstream successfully deleted tag", "did", commit.DID, "repository", repo, "tag", tag)
 		return nil
 	}