Added a dedicated logger with prefix to most services

cmd/main.go

···
 		lastfmInterval = 30 * time.Second
 	}
 
-	if err := spotifyService.LoadAllUsers(); err != nil {
-		log.Printf("Warning: Failed to preload Spotify users: %v", err)
-	}
+	//if err := spotifyService.LoadAllUsers(); err != nil {
+	//	log.Printf("Warning: Failed to preload Spotify users: %v", err)
+	//}
 	go spotifyService.StartListeningTracker(trackerInterval)
 
 	go lastfmService.StartListeningTracker(lastfmInterval)

oauth/oauth_manager.go

···
 	services       map[string]AuthService
 	sessionManager *session.SessionManager
 	mu             sync.RWMutex
+	logger         *log.Logger
 }
 
 func NewOAuthServiceManager(sessionManager *session.SessionManager) *OAuthServiceManager {
 	return &OAuthServiceManager{
 		services:       make(map[string]AuthService),
 		sessionManager: sessionManager,
+		logger:         log.New(log.Writer(), "oauth: ", log.LstdFlags|log.Lmsgprefix),
 	}
 }
 
···
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.services[name] = service
-	log.Printf("Registered auth service: %s", name)
+	m.logger.Printf("Registered auth service: %s", name)
 }
 
 // get an AuthService by registered name
···
 			return
 		}
 
-		log.Printf("Auth service '%s' not found for login request", serviceName)
+		m.logger.Printf("Auth service '%s' not found for login request", serviceName)
 		http.Error(w, fmt.Sprintf("Auth service '%s' not found", serviceName), http.StatusNotFound)
 	}
 }
···
 		service, exists := m.services[serviceName]
 		m.mu.RUnlock()
 
-		log.Printf("Logging in with service %s", serviceName)
+		m.logger.Printf("Logging in with service %s", serviceName)
 
 		if !exists {
-			log.Printf("Auth service '%s' not found for callback request", serviceName)
+			m.logger.Printf("Auth service '%s' not found for callback request", serviceName)
 			http.Error(w, fmt.Sprintf("OAuth service '%s' not found", serviceName), http.StatusNotFound)
 			return
 		}
···
 		userID, err := service.HandleCallback(w, r)
 
 		if err != nil {
-			log.Printf("Error handling callback for service '%s': %v", serviceName, err)
+			m.logger.Printf("Error handling callback for service '%s': %v", serviceName, err)
 			http.Error(w, fmt.Sprintf("Error handling callback for service '%s'", serviceName), http.StatusInternalServerError)
 			return
 		}
···
 
 			m.sessionManager.SetSessionCookie(w, session)
 
-			log.Printf("Created session for user %d via service %s", userID, serviceName)
+			m.logger.Printf("Created session for user %d via service %s", userID, serviceName)
 
 			http.Redirect(w, r, "/", http.StatusSeeOther)
 		} else {
-			log.Printf("Callback for service '%s' did not result in a valid user ID.", serviceName)
+			m.logger.Printf("Callback for service '%s' did not result in a valid user ID.", serviceName)
 			// todo: redirect to an error page
 			// right now this just redirects home but we don't want this behaviour ideally
 			http.Redirect(w, r, "/", http.StatusSeeOther)

service/lastfm/lastfm.go

···
 	"log"
 	"net/http"
 	"net/url"
+	"os"
 	"strconv"
 	"sync"
 	"time"
···
 	atprotoService     *atprotoauth.ATprotoAuthService
 	lastSeenNowPlaying map[string]Track
 	mu                 sync.Mutex
+	logger             *log.Logger
 }
 
 func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService, atprotoService *atprotoauth.ATprotoAuthService) *LastFMService {
+	logger := log.New(os.Stdout, "lastfm: ", log.LstdFlags|log.Lmsgprefix)
+
 	return &LastFMService{
 		db: db,
 		httpClient: &http.Client{
···
 		musicBrainzService: musicBrainzService,
 		lastSeenNowPlaying: make(map[string]Track),
 		mu:                 sync.Mutex{},
+		logger:             logger,
 	}
 }
 
 func (l *LastFMService) loadUsernames() error {
 	u, err := l.db.GetAllUsersWithLastFM()
 	if err != nil {
-		log.Printf("Error loading users with Last.fm from DB: %v", err)
+		l.logger.Printf("Error loading users with Last.fm from DB: %v", err)
 		return fmt.Errorf("failed to load users from database: %w", err)
 	}
 	usernames := make([]string, len(u))
···
 		if user.LastFMUsername != nil { // Check if the username is set
 			usernames[i] = *user.LastFMUsername
 		} else {
-			log.Printf("User ID %d has Last.fm enabled but no username set", user.ID)
+			l.logger.Printf("User ID %d has Last.fm enabled but no username set", user.ID)
 		}
 	}
 
···
 	}
 
 	l.Usernames = filteredUsernames
-	log.Printf("Loaded %d Last.fm usernames", len(l.Usernames))
+	l.logger.Printf("Loaded %d Last.fm usernames", len(l.Usernames))
 
 	return nil
 }
···
 		return nil, fmt.Errorf("failed to create request for %s: %w", username, err)
 	}
 
-	log.Printf("Fetching recent tracks for user: %s", username)
+	l.logger.Printf("Fetching recent tracks for user: %s", username)
 	resp, err := l.httpClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch recent tracks for %s: %w", username, err)
···
 	}
 	if err := json.Unmarshal(bodyBytes, &recentTracksResp); err != nil {
 		// Log the body content that failed to decode
-		log.Printf("Failed to decode response body for %s: %s", username, string(bodyBytes))
+		l.logger.Printf("Failed to decode response body for %s: %s", username, string(bodyBytes))
 		return nil, fmt.Errorf("failed to decode response for %s: %w", username, err)
 	}
 
 	if len(recentTracksResp.RecentTracks.Tracks) > 0 {
-		log.Printf("Fetched %d tracks for %s. Most recent: %s - %s",
+		l.logger.Printf("Fetched %d tracks for %s. Most recent: %s - %s",
 			len(recentTracksResp.RecentTracks.Tracks),
 			username,
 			recentTracksResp.RecentTracks.Tracks[0].Artist.Text,
 			recentTracksResp.RecentTracks.Tracks[0].Name)
 	} else {
-		log.Printf("No recent tracks found for %s", username)
+		l.logger.Printf("No recent tracks found for %s", username)
 	}
 
 	return &recentTracksResp, nil
···
 
 func (l *LastFMService) StartListeningTracker(interval time.Duration) {
 	if err := l.loadUsernames(); err != nil {
-		log.Printf("Failed to perform initial username load: %v", err)
+		l.logger.Printf("Failed to perform initial username load: %v", err)
 		// Decide if we should proceed without initial load or return error
 	}
 
 	if len(l.Usernames) == 0 {
-		log.Println("No Last.fm users configured. Tracker will run but fetch cycles will be skipped until users are added.")
+		l.logger.Println("No Last.fm users configured. Tracker will run but fetch cycles will be skipped until users are added.")
 	} else {
-		log.Printf("Found %d Last.fm users.", len(l.Usernames))
+		l.logger.Printf("Found %d Last.fm users.", len(l.Usernames))
 	}
 
 	ticker := time.NewTicker(interval)
···
 		if len(l.Usernames) > 0 {
 			l.fetchAllUserTracks(context.Background())
 		} else {
-			log.Println("Skipping initial fetch cycle as no users are configured.")
+			l.logger.Println("Skipping initial fetch cycle as no users are configured.")
 		}
 
 		for {
···
 			case <-ticker.C:
 				// refresh usernames periodically from db
 				if err := l.loadUsernames(); err != nil {
-					log.Printf("Error reloading usernames in ticker: %v", err)
+					l.logger.Printf("Error reloading usernames in ticker: %v", err)
 					// Continue ticker loop even if reload fails? Or log and potentially stop?
 					continue // Continue for now
 				}
 				if len(l.Usernames) > 0 {
 					l.fetchAllUserTracks(context.Background())
 				} else {
-					log.Println("No Last.fm users configured. Skipping fetch cycle.")
+					l.logger.Println("No Last.fm users configured. Skipping fetch cycle.")
 				}
 				// TODO: Implement graceful shutdown using context cancellation
 				// case <-ctx.Done():
-				//  log.Println("Stopping Last.fm listening tracker.")
+				//  l.logger.Println("Stopping Last.fm listening tracker.")
 				//	ticker.Stop()
 				//  return
 			}
 		}
 	}()
 
-	log.Printf("Last.fm Listening Tracker started with interval %v", interval)
+	l.logger.Printf("Last.fm Listening Tracker started with interval %v", interval)
 }
 
 // fetchAllUserTracks iterates through users and fetches their tracks.
 func (l *LastFMService) fetchAllUserTracks(ctx context.Context) {
-	log.Printf("Starting fetch cycle for %d users...", len(l.Usernames))
+	l.logger.Printf("Starting fetch cycle for %d users...", len(l.Usernames))
 	var wg sync.WaitGroup                             // Use WaitGroup to fetch concurrently (optional)
 	fetchErrors := make(chan error, len(l.Usernames)) // Channel for errors
 
 	for _, username := range l.Usernames {
 		if ctx.Err() != nil {
-			log.Printf("Context cancelled before starting fetch for user %s.", username)
+			l.logger.Printf("Context cancelled before starting fetch for user %s.", username)
 			break // Exit loop if context is cancelled
 		}
 
···
 		go func(uname string) { // Launch fetch and process in a goroutine per user
 			defer wg.Done()
 			if ctx.Err() != nil {
-				log.Printf("Context cancelled during fetch cycle for user %s.", uname)
+				l.logger.Printf("Context cancelled during fetch cycle for user %s.", uname)
 				return // Exit goroutine if context is cancelled
 			}
 
···
 			const fetchLimit = 5
 			recentTracks, err := l.getRecentTracks(ctx, uname, fetchLimit)
 			if err != nil {
-				log.Printf("Error fetching tracks for %s: %v", uname, err)
+				l.logger.Printf("Error fetching tracks for %s: %v", uname, err)
 				fetchErrors <- fmt.Errorf("fetch failed for %s: %w", uname, err) // Report error
 				return
 			}
 
 			if recentTracks == nil || len(recentTracks.RecentTracks.Tracks) == 0 {
-				log.Printf("No tracks returned for user %s", uname)
+				l.logger.Printf("No tracks returned for user %s", uname)
 				return
 			}
 
 			// Process the fetched tracks
 			if err := l.processTracks(ctx, uname, recentTracks.RecentTracks.Tracks); err != nil {
-				log.Printf("Error processing tracks for %s: %v", uname, err)
+				l.logger.Printf("Error processing tracks for %s: %v", uname, err)
 				fetchErrors <- fmt.Errorf("process failed for %s: %w", uname, err) // Report error
 			}
 		}(username)
···
 	// Log any errors that occurred during the fetch cycle
 	errorCount := 0
 	for err := range fetchErrors {
-		log.Printf("Fetch cycle error: %v", err)
+		l.logger.Printf("Fetch cycle error: %v", err)
 		errorCount++
 	}
 
 	if errorCount > 0 {
-		log.Printf("Finished fetch cycle with %d errors.", errorCount)
+		l.logger.Printf("Finished fetch cycle with %d errors.", errorCount)
 	} else {
-		log.Println("Finished fetch cycle successfully.")
+		l.logger.Println("Finished fetch cycle successfully.")
 	}
 }
 
···
 	}
 
 	if lastKnownTimestamp == nil {
-		log.Printf("no previous scrobble timestamp found for user %s. processing latest track.", username)
+		l.logger.Printf("no previous scrobble timestamp found for user %s. processing latest track.", username)
 	} else {
-		log.Printf("last known scrobble for %s was at %s", username, lastKnownTimestamp.Format(time.RFC3339))
+		l.logger.Printf("last known scrobble for %s was at %s", username, lastKnownTimestamp.Format(time.RFC3339))
 	}
 
 	var (
···
 	// handle now playing track separately
 	if len(tracks) > 0 && tracks[0].Attr != nil && tracks[0].Attr.NowPlaying == "true" {
 		nowPlayingTrack := tracks[0]
-		log.Printf("now playing track for %s: %s - %s", username, nowPlayingTrack.Artist.Text, nowPlayingTrack.Name)
+		l.logger.Printf("now playing track for %s: %s - %s", username, nowPlayingTrack.Artist.Text, nowPlayingTrack.Name)
 		l.mu.Lock()
 		lastSeen, existed := l.lastSeenNowPlaying[username]
 		// if our current track matches with last seen
 		// just compare artist/album/name for now
 		if existed && lastSeen.Album == nowPlayingTrack.Album && lastSeen.Name == nowPlayingTrack.Name && lastSeen.Artist == nowPlayingTrack.Artist {
-			log.Printf("current track matches last seen track for %s", username)
+			l.logger.Printf("current track matches last seen track for %s", username)
 		} else {
-			log.Printf("current track does not match last seen track for %s", username)
+			l.logger.Printf("current track does not match last seen track for %s", username)
 			// aha! we record this!
 			l.lastSeenNowPlaying[username] = nowPlayingTrack
 		}
···
 	}
 
 	if lastNonNowPlaying == nil {
-		log.Printf("no non-now-playing tracks found for user %s.", username)
+		l.logger.Printf("no non-now-playing tracks found for user %s.", username)
 		return nil
 	}
 
 	latestTrackTime := lastNonNowPlaying.Date
 
 	// print both
-	fmt.Printf("latestTrackTime: %s\n", latestTrackTime)
-	fmt.Printf("lastKnownTimestamp: %s\n", lastKnownTimestamp)
+	l.logger.Printf("latestTrackTime: %s\n", latestTrackTime)
+	l.logger.Printf("lastKnownTimestamp: %s\n", lastKnownTimestamp)
 
 	if lastKnownTimestamp != nil && lastKnownTimestamp.Equal(latestTrackTime.Time) {
-		log.Printf("no new tracks to process for user %s.", username)
+		l.logger.Printf("no new tracks to process for user %s.", username)
 		return nil
 	}
 
 	for _, track := range tracks {
 		if track.Date == nil {
-			log.Printf("skipping track without timestamp for %s: %s - %s", username, track.Artist.Text, track.Name)
+			l.logger.Printf("skipping track without timestamp for %s: %s - %s", username, track.Artist.Text, track.Name)
 			continue
 		}
 
···
 		// before or at last known
 		if lastKnownTimestamp != nil && (trackTime.Before(*lastKnownTimestamp) || trackTime.Equal(*lastKnownTimestamp)) {
 			if processedCount == 0 {
-				log.Printf("reached already known scrobbles for user %s (track time: %s, last known: %s).",
+				l.logger.Printf("reached already known scrobbles for user %s (track time: %s, last known: %s).",
 					username, trackTime.Format(time.RFC3339), lastKnownTimestamp.Format(time.RFC3339))
 			}
 			break
···
 
 		hydratedTrack, err := musicbrainz.HydrateTrack(l.musicBrainzService, baseTrack)
 		if err != nil {
-			log.Printf("error hydrating track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
+			l.logger.Printf("error hydrating track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
 			// we can use the track without MBIDs, it's still valid
 			hydratedTrack = &baseTrack
 		}
 		l.db.SaveTrack(user.ID, hydratedTrack)
-		log.Printf("Submitting track")
+		l.logger.Printf("Submitting track")
 		err = l.SubmitTrackToPDS(*user.ATProtoDID, hydratedTrack, ctx)
 		if err != nil {
-			log.Printf("error submitting track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
+			l.logger.Printf("error submitting track for user %s: %s - %s: %v", username, track.Artist.Text, track.Name, err)
 		}
 		processedCount++
 
···
 	}
 
 	if processedCount > 0 {
-		log.Printf("processed %d new track(s) for user %s. latest timestamp: %s",
+		l.logger.Printf("processed %d new track(s) for user %s. latest timestamp: %s",
 			processedCount, username, latestProcessedTime.Format(time.RFC3339))
 	}
 
···
 	}
 
 	// printout the session details
-	fmt.Printf("Submitting track for the did: %+v\n", sess.DID)
+	l.logger.Printf("Submitting track for the did: %+v\n", sess.DID)
 
 	artists := make([]*teal.AlphaFeedDefs_Artist, 0, len(track.Artist))
 	for _, a := range track.Artist {

service/musicbrainz/musicbrainz.go

···
 	"log"
 	"net/http"
 	"net/url"
+	"os"
 	"sort"
 	"strings"
 	"sync" // Added for mutex
···
 	cacheMutex  sync.RWMutex          // Mutex to protect the cache
 	cacheTTL    time.Duration         // Time-to-live for cache entries
 	cleaner     MetadataCleaner       // Cleaner for cleaning up expired cache entries
+	logger      *log.Logger           // Logger for logging
 }
 
 // NewMusicBrainzService creates a new service instance with rate limiting and caching.
···
 	limiter := rate.NewLimiter(rate.Every(time.Second), 1)
 	// Set a default cache TTL (e.g., 1 hour)
 	defaultCacheTTL := 1 * time.Hour
-
+	logger := log.New(os.Stdout, "musicbrainz: ", log.LstdFlags|log.Lmsgprefix)
 	return &MusicBrainzService{
 		db: db,
 		httpClient: &http.Client{
···
 		cacheTTL:    defaultCacheTTL,              // Set the cache TTL
 		cleaner:     *NewMetadataCleaner("Latin"), // Initialize the cleaner
 		// cacheMutex is zero-value ready
+		logger: logger,
 	}
 }
 
···
 	s.cacheMutex.RUnlock()
 
 	if found && now.Before(entry.expiresAt) {
-		log.Printf("Cache hit for MusicBrainz search: key=%s", cacheKey)
+		s.logger.Printf("Cache hit for MusicBrainz search: key=%s", cacheKey)
 		// Return the cached data directly. Consider if a deep copy is needed if callers modify results.
 		return entry.recordings, nil
 	}
 	// --- Cache Miss or Expired ---
 	if found {
-		log.Printf("Cache expired for MusicBrainz search: key=%s", cacheKey)
+		s.logger.Printf("Cache expired for MusicBrainz search: key=%s", cacheKey)
 	} else {
-		log.Printf("Cache miss for MusicBrainz search: key=%s", cacheKey)
+		s.logger.Printf("Cache miss for MusicBrainz search: key=%s", cacheKey)
 	}
 
 	// --- Proceed with API call ---
···
 		expiresAt:  time.Now().UTC().Add(s.cacheTTL),
 	}
 	s.cacheMutex.Unlock()
-	log.Printf("Cached MusicBrainz search result for key=%s, TTL=%s", cacheKey, s.cacheTTL)
+	s.logger.Printf("Cached MusicBrainz search result for key=%s, TTL=%s", cacheKey, s.cacheTTL)
 
 	// Return the newly fetched results
 	return result.Recordings, nil
 }
 
 // GetBestRelease selects the 'best' release from a list based on specific criteria.
-func GetBestRelease(releases []MusicBrainzRelease, trackTitle string) *MusicBrainzRelease {
+func (s *MusicBrainzService) GetBestRelease(releases []MusicBrainzRelease, trackTitle string) *MusicBrainzRelease {
 	if len(releases) == 0 {
 		return nil
 	}
···
 	}
 
 	// 3. If none found, return the oldest release overall (which is the first one after sorting)
-	log.Printf("Could not find a suitable release for '%s', picking oldest: '%s' (%s)", trackTitle, releases[0].Title, releases[0].ID)
+	s.logger.Printf("Could not find a suitable release for '%s', picking oldest: '%s' (%s)", trackTitle, releases[0].Title, releases[0].ID)
 	r := releases[0]
 	return &r
 }
···
 	}
 
 	firstResult := res[0]
-	firstResultAlbum := GetBestRelease(firstResult.Releases, firstResult.Title)
+	firstResultAlbum := mb.GetBestRelease(firstResult.Releases, firstResult.Title)
 
 	// woof. we Might not have any ISRCs!
 	var bestISRC string

service/spotify/spotify.go

···
 	"log"
 	"net/http"
 	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"time"
···
 	userTracks     map[int64]*models.Track
 	userTokens     map[int64]string
 	mu             sync.RWMutex
+	logger         *log.Logger
 }
 
 func NewSpotifyService(database *db.DB, atprotoService *atprotoauth.ATprotoAuthService, musicBrainzService *musicbrainz.MusicBrainzService) *SpotifyService {
+	logger := log.New(os.Stdout, "spotify: ", log.LstdFlags|log.Lmsgprefix)
+
 	return &SpotifyService{
 		DB:             database,
 		atprotoService: atprotoService,
 		mb:             musicBrainzService,
 		userTracks:     make(map[int64]*models.Track),
 		userTokens:     make(map[int64]string),
+		logger:         logger,
 	}
 }
 
 func (s *SpotifyService) SubmitTrackToPDS(did string, track *models.Track, ctx context.Context) error {
 	client, err := s.atprotoService.GetATProtoClient()
 	if err != nil || client == nil {
-		log.Printf("Error getting ATProto client: %v", err)
+		s.logger.Printf("Error getting ATProto client: %v", err)
 		return fmt.Errorf("failed to get ATProto client: %w", err)
 	}
 
···
 
 	var out atproto.RepoCreateRecord_Output
 	if err := xrpcClient.Do(ctx, authArgs, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
-		log.Printf("Error creating record for DID %s: %v. Input: %+v", did, err, input)
+		s.logger.Printf("Error creating record for DID %s: %v. Input: %+v", did, err, input)
 		return fmt.Errorf("failed to create record on PDS for DID %s: %w", did, err)
 	}
 
-	log.Printf("Successfully submitted track '%s' to PDS for DID %s. Record URI: %s", track.Name, did, out.Uri)
+	s.logger.Printf("Successfully submitted track '%s' to PDS for DID %s. Record URI: %s", track.Name, did, out.Uri)
 	return nil
 }
 
 func (s *SpotifyService) SetAccessToken(token string, refreshToken string, userId int64, hasSession bool) (int64, error) {
 	userID, err := s.identifyAndStoreUser(token, refreshToken, userId, hasSession)
 	if err != nil {
-		log.Printf("Error identifying and storing user: %v", err)
+		s.logger.Printf("Error identifying and storing user: %v", err)
 		return 0, err
 	}
 	return userID, nil
···
 func (s *SpotifyService) identifyAndStoreUser(token string, refreshToken string, userId int64, hasSession bool) (int64, error) {
 	userProfile, err := s.fetchSpotifyProfile(token)
 	if err != nil {
-		log.Printf("Error fetching Spotify profile: %v", err)
+		s.logger.Printf("Error fetching Spotify profile: %v", err)
 		return 0, err
 	}
 
-	fmt.Printf("uid: %d hasSession: %t", userId, hasSession)
+	s.logger.Printf("uid: %d hasSession: %t", userId, hasSession)
 
 	user, err := s.DB.GetUserBySpotifyID(userProfile.ID)
 	if err != nil {
 		// This error might mean DB connection issue, not just user not found.
-		log.Printf("Error checking for user by Spotify ID %s: %v", userProfile.ID, err)
+		s.logger.Printf("Error checking for user by Spotify ID %s: %v", userProfile.ID, err)
 		return 0, err
 	}
 
···
 	// We don't intend users to log in via spotify!
 	if user == nil {
 		if !hasSession {
-			log.Printf("User does not seem to exist")
+			s.logger.Printf("User does not seem to exist")
 			return 0, fmt.Errorf("user does not seem to exist")
 		} else {
 			// overwrite prev user
 			user, err = s.DB.AddSpotifySession(userId, userProfile.DisplayName, userProfile.Email, userProfile.ID, token, refreshToken, tokenExpiryTime)
 			if err != nil {
-				log.Printf("Error adding Spotify session for user ID %d: %v", userId, err)
+				s.logger.Printf("Error adding Spotify session for user ID %d: %v", userId, err)
 				return 0, err
 			}
 		}
···
 		err = s.DB.UpdateUserToken(user.ID, token, refreshToken, tokenExpiryTime)
 		if err != nil {
 			// for now log and continue
-			log.Printf("Error updating user token for user ID %d: %v", user.ID, err)
+			s.logger.Printf("Error updating user token for user ID %d: %v", user.ID, err)
 		} else {
-			log.Printf("Updated token for existing user: %s (ID: %d)", *user.Username, user.ID)
+			s.logger.Printf("Updated token for existing user: %s (ID: %d)", *user.Username, user.ID)
 		}
 	}
 	user.AccessToken = &token
···
 	s.userTokens[user.ID] = token
 	s.mu.Unlock()
 
-	log.Printf("User authenticated via Spotify: %s (ID: %d)", *user.Username, user.ID)
+	s.logger.Printf("User authenticated via Spotify: %s (ID: %d)", *user.Username, user.ID)
 	return user.ID, nil
 }
 
···
 			token, err := s.refreshTokenInner(user.ID)
 			if err != nil {
 				//Probably should remove the access token and refresh in long run?
-				log.Printf("Error refreshing token for user %d: %v", user.ID, err)
+				s.logger.Printf("Error refreshing token for user %d: %v", user.ID, err)
 				continue
 			}
 			s.userTokens[user.ID] = token
 		}
 	}
 
-	log.Printf("Loaded %d active users with valid tokens", count)
+	s.logger.Printf("Loaded %d active users with valid tokens", count)
 	return nil
 }
 
···
 		// Also clear the bad refresh token from the DB
 		updateErr := s.DB.UpdateUserToken(userID, "", "", time.Now().UTC()) // Clear tokens
 		if updateErr != nil {
-			log.Printf("Failed to clear bad refresh token for user %d: %v", userID, updateErr)
+			s.logger.Printf("Failed to clear bad refresh token for user %d: %v", userID, updateErr)
 		}
 		return "", fmt.Errorf("spotify token refresh failed (%d): %s", resp.StatusCode, string(body))
 	}
···
 	// Update DB
 	if err := s.DB.UpdateUserToken(userID, tokenResponse.AccessToken, newRefreshToken, newExpiry); err != nil {
 		// Log error but continue, as we have the token in memory
-		log.Printf("Error updating user token in DB for user %d after refresh: %v", userID, err)
+		s.logger.Printf("Error updating user token in DB for user %d after refresh: %v", userID, err)
 	}
 
 	// Update in-memory cache
···
 	s.userTokens[userID] = tokenResponse.AccessToken
 	s.mu.Unlock()
 
-	log.Printf("Successfully refreshed token for user %d", userID)
+	s.logger.Printf("Successfully refreshed token for user %d", userID)
 	return tokenResponse.AccessToken, nil
 }
 
···
 func (s *SpotifyService) RefreshExpiredTokens() {
 	users, err := s.DB.GetUsersWithExpiredTokens()
 	if err != nil {
-		log.Printf("Error fetching users with expired tokens: %v", err)
+		s.logger.Printf("Error fetching users with expired tokens: %v", err)
 		return
 	}
 
···
 
 		if err != nil {
 			// just print out errors here for now
-			log.Printf("Error from service/spotify/spotify.go when refreshing tokens: %s", err.Error())
+			s.logger.Printf("Error from service/spotify/spotify.go when refreshing tokens: %s", err.Error())
 		}
 
 		refreshed++
 	}
 
 	if refreshed > 0 {
-		log.Printf("Refreshed tokens for %d users", refreshed)
+		s.logger.Printf("Refreshed tokens for %d users", refreshed)
 	}
 }
 
···
 	tracks, err := s.DB.GetRecentTracks(userID, 20)
 	if err != nil {
 		http.Error(w, "Error retrieving track history", http.StatusInternalServerError)
-		log.Printf("Error retrieving track history: %v", err)
+		s.logger.Printf("Error retrieving track history: %v", err)
 		return
 	}
 
···
 
 		// oops, token expired or other client error
 		if resp.StatusCode == 401 && attempt == 0 { // Only refresh on 401 on the first attempt
-			log.Printf("Spotify token potentially expired for user %d, attempting refresh...", userID)
+			s.logger.Printf("Spotify token potentially expired for user %d, attempting refresh...", userID)
 			newAccessToken, refreshErr := s.refreshTokenInner(userID)
 			if refreshErr != nil {
-				log.Printf("Token refresh failed for user %d: %v", userID, refreshErr)
+				s.logger.Printf("Token refresh failed for user %d: %v", userID, refreshErr)
 				// No point retrying if refresh failed
 				return nil, fmt.Errorf("spotify token expired or invalid for user %d and refresh failed: %w", userID, refreshErr)
 			}
-			log.Printf("Token refreshed for user %d, retrying request...", userID)
+			s.logger.Printf("Token refreshed for user %d, retrying request...", userID)
 			token = newAccessToken                           // Update token for the next attempt
 			req.Header.Set("Authorization", "Bearer "+token) // Update header for retry
 			continue                                         // Go to next attempt in the loop
···
 	for range ticker.C {
 		err := s.LoadAllUsers()
 		if err != nil {
-			log.Printf("Error loading spotify users: %v", err)
+			s.logger.Printf("Error loading spotify users: %v", err)
 			continue
 		}
 		// copy userIDs to avoid holding the lock too long
···
 		for _, userID := range userIDs {
 			track, err := s.FetchCurrentTrack(userID)
 			if err != nil {
-				log.Printf("Error fetching track for user %d: %v", userID, err)
+				s.logger.Printf("Error fetching track for user %d: %v", userID, err)
 				continue
 			}
 
···
 
 			// just log when we stamp tracks
 			if isNewTrack && isLastTrackStamped && !currentTrack.HasStamped {
-				log.Printf("User %d stamped (previous) track: %s by %s", userID, currentTrack.Name, currentTrack.Artist)
+				s.logger.Printf("User %d stamped (previous) track: %s by %s", userID, currentTrack.Name, currentTrack.Artist)
 				currentTrack.HasStamped = true
 				if currentTrack.PlayID != 0 {
 					s.DB.UpdateTrack(currentTrack.PlayID, currentTrack)
 
-					log.Printf("Updated!")
+					s.logger.Printf("Updated!")
 				}
 			}
 
 			if isStamped && !currentTrack.HasStamped {
-				log.Printf("User %d stamped track: %s by %s", userID, track.Name, track.Artist)
+				s.logger.Printf("User %d stamped track: %s by %s", userID, track.Name, track.Artist)
 				track.HasStamped = true
 				// if currenttrack has a playid and the last track is the same as the current track
 				if !isNewTrack && currentTrack.PlayID != 0 {
···
 					s.userTracks[userID] = track
 					s.mu.Unlock()
 
-					log.Printf("Updated!")
+					s.logger.Printf("Updated!")
 				}
 			}
 
 			if isNewTrack {
 				id, err := s.DB.SaveTrack(userID, track)
 				if err != nil {
-					log.Printf("Error saving track for user %d: %v", userID, err)
+					s.logger.Printf("Error saving track for user %d: %v", userID, err)
 					continue
 				}
 
···
 				// The 'track' variable is *models.Track and has been saved to DB, PlayID is populated.
 				dbUser, errUser := s.DB.GetUserByID(userID) // Fetch user by their internal ID
 				if errUser != nil {
-					log.Printf("User %d: Error fetching user details for PDS submission: %v", userID, errUser)
+					s.logger.Printf("User %d: Error fetching user details for PDS submission: %v", userID, errUser)
 				} else if dbUser == nil {
-					log.Printf("User %d: User not found in DB. Skipping PDS submission.", userID)
+					s.logger.Printf("User %d: User not found in DB. Skipping PDS submission.", userID)
 				} else if dbUser.ATProtoDID == nil || *dbUser.ATProtoDID == "" {
-					log.Printf("User %d (%d): ATProto DID not set. Skipping PDS submission for track '%s'.", userID, dbUser.ATProtoDID, track.Name)
+					s.logger.Printf("User %d (%d): ATProto DID not set. Skipping PDS submission for track '%s'.", userID, dbUser.ATProtoDID, track.Name)
 				} else {
 					// User has a DID, proceed with hydration and submission
 					var trackToSubmitToPDS *models.Track = track // Default to the original track (already *models.Track)
···
 						// and it returns *models.Track
 						hydratedTrack, errHydrate := musicbrainz.HydrateTrack(s.mb, *track)
 						if errHydrate != nil {
-							log.Printf("User %d (%d): Error hydrating track '%s' with MusicBrainz: %v. Proceeding with original track data for PDS.", userID, dbUser.ATProtoDID, track.Name, errHydrate)
+							s.logger.Printf("User %d (%d): Error hydrating track '%s' with MusicBrainz: %v. Proceeding with original track data for PDS.", userID, dbUser.ATProtoDID, track.Name, errHydrate)
 						} else {
-							log.Printf("User %d (%d): Successfully hydrated track '%s' with MusicBrainz.", userID, dbUser.ATProtoDID, track.Name)
+							s.logger.Printf("User %d (%d): Successfully hydrated track '%s' with MusicBrainz.", userID, dbUser.ATProtoDID, track.Name)
 							trackToSubmitToPDS = hydratedTrack // hydratedTrack is *models.Track
 						}
 					} else {
-						log.Printf("User %d (%d): MusicBrainz service not configured. Proceeding with original track data for PDS.", userID, dbUser.ATProtoDID)
+						s.logger.Printf("User %d (%d): MusicBrainz service not configured. Proceeding with original track data for PDS.", userID, dbUser.ATProtoDID)
 					}
 
 					artistName := "Unknown Artist"
···
 						artistName = trackToSubmitToPDS.Artist[0].Name
 					}
 
-					log.Printf("User %d (%d): Attempting to submit track '%s' by %s to PDS (DID: %s)", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name, artistName, *dbUser.ATProtoDID)
+					s.logger.Printf("User %d (%d): Attempting to submit track '%s' by %s to PDS (DID: %s)", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name, artistName, *dbUser.ATProtoDID)
 					// Use context.Background() for now, or pass down a context if available
 					if errPDS := s.SubmitTrackToPDS(*dbUser.ATProtoDID, trackToSubmitToPDS, context.Background()); errPDS != nil {
-						log.Printf("User %d (%d): Error submitting track '%s' to PDS: %v", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name, errPDS)
+						s.logger.Printf("User %d (%d): Error submitting track '%s' to PDS: %v", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name, errPDS)
 					} else {
-						log.Printf("User %d (%d): Successfully submitted track '%s' to PDS.", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name)
+						s.logger.Printf("User %d (%d): Successfully submitted track '%s' to PDS.", userID, dbUser.ATProtoDID, trackToSubmitToPDS.Name)
 					}
 				}
 				// End of PDS submission block
 
-				log.Printf("User %d is listening to: %s by %s", userID, track.Name, track.Artist)
+				s.logger.Printf("User %d is listening to: %s by %s", userID, track.Name, track.Artist)
 			}
 		}
 
 		//unloading users to save memory and make sure we get new signups
 		err = s.LoadAllUsers()
 		if err != nil {
-			log.Printf("Error loading spotify users: %v", err)
+			s.logger.Printf("Error loading spotify users: %v", err)
 		}
 	}
 }