plexautolang: cache episode information to avoid redundant api calls

Author: saltydk

internal/plexautolang/cache.go

@@ -31,6 +31,13 @@ type MachineIdentifier struct {
 	CachedAt time.Time
 }
 
+// SessionEpisode caches episode metadata for an active session
+type SessionEpisode struct {
+	Episode   *Episode
+	RatingKey string
+	CachedAt  time.Time
+}
+
 // Cache holds in-memory caches for Plex Auto Languages
 type Cache struct {
 	mu sync.RWMutex
@@ -61,6 +68,9 @@ type Cache struct {
 	// lastProcessed tracks when we last processed a client/ratingKey combo
 	// Key: "clientIdentifier:ratingKey"
 	lastProcessed map[string]time.Time
+
+	// sessionEpisodes caches episode metadata per session key
+	sessionEpisodes map[string]*SessionEpisode
 }
 
 // NewCache creates a new cache instance
@@ -73,6 +83,7 @@ func NewCache() *Cache {
 		newlyAdded:       make(map[string]time.Time),
 		recentActivities: make(map[string]time.Time),
 		lastProcessed:    make(map[string]time.Time),
+		sessionEpisodes:  make(map[string]*SessionEpisode),
 	}
 }
 
@@ -95,6 +106,41 @@ func (c *Cache) SetSessionState(sessionKey, state string) {
 	}
 }
 
+// GetSessionEpisode returns the cached episode for a session key
+func (c *Cache) GetSessionEpisode(sessionKey, ratingKey string) (*Episode, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	sessionEpisode, ok := c.sessionEpisodes[sessionKey]
+	if !ok || sessionEpisode == nil {
+		return nil, false
+	}
+	if ratingKey != "" && sessionEpisode.RatingKey != ratingKey {
+		return nil, false
+	}
+	return sessionEpisode.Episode, true
+}
+
+// SetSessionEpisode caches episode metadata for a session key
+func (c *Cache) SetSessionEpisode(sessionKey, ratingKey string, episode *Episode) {
+	if sessionKey == "" || episode == nil {
+		return
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.sessionEpisodes[sessionKey] = &SessionEpisode{
+		Episode:   episode,
+		RatingKey: ratingKey,
+		CachedAt:  time.Now(),
+	}
+}
+
+// ClearSessionEpisode removes cached episode metadata for a session key
+func (c *Cache) ClearSessionEpisode(sessionKey string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.sessionEpisodes, sessionKey)
+}
+
 // GetDefaultStreams returns the cached default streams for an episode and user
 func (c *Cache) GetDefaultStreams(userID, ratingKey string) (*StreamSelection, bool) {
 	c.mu.RLock()
@@ -296,6 +342,17 @@ func (c *Cache) CleanupExpired(maxAge time.Duration) {
 			delete(c.lastProcessed, key)
 		}
 	}
+
+	// Clean up session episode cache
+	for key, sessionEpisode := range c.sessionEpisodes {
+		if sessionEpisode == nil {
+			delete(c.sessionEpisodes, key)
+			continue
+		}
+		if now.Sub(sessionEpisode.CachedAt) > maxAge {
+			delete(c.sessionEpisodes, key)
+		}
+	}
 }
 
 // Clear removes all entries from all caches
@@ -310,6 +367,7 @@ func (c *Cache) Clear() {
 	c.newlyAdded = make(map[string]time.Time)
 	c.recentActivities = make(map[string]time.Time)
 	c.lastProcessed = make(map[string]time.Time)
+	c.sessionEpisodes = make(map[string]*SessionEpisode)
 }
 
 func defaultStreamKey(userID, ratingKey string) string {

internal/plexautolang/manager.go

@@ -449,18 +449,18 @@ func (m *Manager) handlePlayingNotification(targetID int64, target PlexTargetInt
 			return
 		}
 		m.enqueueTask(targetID, config.MaxConcurrent, func() {
-			m.processPlayingSession(targetID, target, cache, playing.ClientIdentifier, ratingKey, config)
+			m.processPlayingSession(targetID, target, cache, sessionKey, playing.ClientIdentifier, ratingKey, config)
 		})
 	} else {
 		// Session stopped - cleanup but also check for final track changes
 		m.enqueueTask(targetID, config.MaxConcurrent, func() {
-			m.processPlaybackStopped(targetID, target, playing.ClientIdentifier, ratingKey, config)
+			m.processPlaybackStopped(targetID, target, sessionKey, playing.ClientIdentifier, ratingKey, config)
 		})
 	}
 }
 
 // processPlayingSession handles an active playing session to detect track changes
-func (m *Manager) processPlayingSession(targetID int64, target PlexTargetInterface, cache *Cache, clientIdentifier string, ratingKey string, config *database.PlexAutoLanguagesConfig) {
+func (m *Manager) processPlayingSession(targetID int64, target PlexTargetInterface, cache *Cache, sessionKey string, clientIdentifier string, ratingKey string, config *database.PlexAutoLanguagesConfig) {
 	ctx, cancel := context.WithTimeout(m.ctx, 30*time.Second)
 	defer cancel()
 
@@ -489,29 +489,28 @@ func (m *Manager) processPlayingSession(targetID int64, target PlexTargetInterfa
 		userToken = ""
 	}
 
-	// Fetch episode metadata using the user's token to see their stream preferences
-	var episode *Episode
-	if userToken != "" {
-		episode, err = target.GetEpisodeWithStreamsAsUser(ctx, ratingKey, userToken)
-		if err != nil {
-			log.Debug().Err(err).Str("ratingKey", ratingKey).Str("user", userLabel).Msg("Plex Auto Languages: Failed to get episode as user, clearing token cache")
-			// Token might be invalid, clear it and try again next time
-			cache.ClearUserToken(user.ID)
-			userToken = ""
-			// Fall back to admin token
-			episode, err = target.GetEpisodeWithStreams(ctx, ratingKey)
-			if err != nil {
-				log.Debug().Err(err).Str("ratingKey", ratingKey).Str("user", userLabel).Msg("Plex Auto Languages: Failed to get episode")
-				return
-			}
+	// Prefer live session data to avoid repeated library metadata calls.
+	episode, err := target.GetSessionEpisodeWithStreams(ctx, clientIdentifier, ratingKey)
+	if err != nil {
+		if errors.Is(err, ErrNoActiveSessions) {
+			log.Trace().
+				Str("ratingKey", ratingKey).
+				Str("clientIdentifier", clientIdentifier).
+				Msg("No active sessions found, falling back to cached metadata")
+		} else {
+			log.Trace().
+				Err(err).
+				Str("ratingKey", ratingKey).
+				Str("clientIdentifier", clientIdentifier).
+				Msg("Failed to get live session episode, falling back to cached metadata")
 		}
-	} else {
-		// No user token available, use admin token
-		episode, err = target.GetEpisodeWithStreams(ctx, ratingKey)
+		episode, err = m.getSessionCachedEpisode(ctx, target, cache, sessionKey, ratingKey, user.ID, userLabel, &userToken)
 		if err != nil {
 			log.Debug().Err(err).Str("ratingKey", ratingKey).Str("user", userLabel).Msg("Plex Auto Languages: Failed to get episode")
 			return
 		}
+	} else if cache != nil && sessionKey != "" {
+		cache.SetSessionEpisode(sessionKey, ratingKey, episode)
 	}
 
 	if episode.GrandparentKey == "" || len(episode.Parts) == 0 {
@@ -625,10 +624,18 @@ func (m *Manager) processPlayingSession(targetID int64, target PlexTargetInterfa
 }
 
 // processPlaybackStopped handles when a user stops playing an episode
-func (m *Manager) processPlaybackStopped(targetID int64, target PlexTargetInterface, clientIdentifier string, ratingKey string, config *database.PlexAutoLanguagesConfig) {
+func (m *Manager) processPlaybackStopped(targetID int64, target PlexTargetInterface, sessionKey string, clientIdentifier string, ratingKey string, config *database.PlexAutoLanguagesConfig) {
 	ctx, cancel := context.WithTimeout(m.ctx, 30*time.Second)
 	defer cancel()
 
+	m.mu.RLock()
+	cache := m.caches[targetID]
+	m.mu.RUnlock()
+
+	if cache != nil && sessionKey != "" {
+		defer cache.ClearSessionEpisode(sessionKey)
+	}
+
 	// Get the episode with streams to see what was selected (prefer live session data)
 	liveData := true
 	episode, err := target.GetSessionEpisodeWithStreams(ctx, clientIdentifier, ratingKey)
@@ -675,11 +682,6 @@ func (m *Manager) processPlaybackStopped(targetID int64, target PlexTargetInterf
 	// If live data is gone (session already stopped), try to reapply the last known stream
 	// selection from cache so we don't lose mid-playback changes.
 	if !liveData {
-		var cache *Cache
-		m.mu.RLock()
-		cache = m.caches[targetID]
-		m.mu.RUnlock()
-
 		if cache != nil {
 			if cachedStreams, ok := cache.GetDefaultStreams(user.ID, ratingKey); ok {
 				part := &episode.Parts[0]
@@ -746,10 +748,6 @@ func (m *Manager) processPlaybackStopped(targetID int64, target PlexTargetInterf
 		Msg("Plex Auto Languages: User track preference saved")
 
 	// Apply preference to other episodes
-	m.mu.RLock()
-	cache := m.caches[targetID]
-	m.mu.RUnlock()
-
 	userToken, err := m.getUserToken(ctx, cache, target, user.ID)
 	if err != nil {
 		log.Debug().Err(err).Str("user", userLabel).Msg("Plex Auto Languages: Failed to get user token, skipping apply")
@@ -1352,6 +1350,52 @@ func (m *Manager) getUserToken(ctx context.Context, cache *Cache, target PlexTar
 	return token, nil
 }
 
+func (m *Manager) getSessionCachedEpisode(
+	ctx context.Context,
+	target PlexTargetInterface,
+	cache *Cache,
+	sessionKey string,
+	ratingKey string,
+	userID string,
+	userLabel string,
+	userToken *string,
+) (*Episode, error) {
+	if cache != nil {
+		if cached, ok := cache.GetSessionEpisode(sessionKey, ratingKey); ok {
+			return cached, nil
+		}
+	}
+
+	if userToken != nil && *userToken != "" {
+		episode, err := target.GetEpisodeWithStreamsAsUser(ctx, ratingKey, *userToken)
+		if err == nil {
+			if cache != nil && sessionKey != "" {
+				cache.SetSessionEpisode(sessionKey, ratingKey, episode)
+			}
+			return episode, nil
+		}
+
+		log.Debug().
+			Err(err).
+			Str("ratingKey", ratingKey).
+			Str("user", userLabel).
+			Msg("Plex Auto Languages: Failed to get episode as user, clearing token cache")
+		if cache != nil {
+			cache.ClearUserToken(userID)
+		}
+		*userToken = ""
+	}
+
+	episode, err := target.GetEpisodeWithStreams(ctx, ratingKey)
+	if err != nil {
+		return nil, err
+	}
+	if cache != nil && sessionKey != "" {
+		cache.SetSessionEpisode(sessionKey, ratingKey, episode)
+	}
+	return episode, nil
+}
+
 // tracksMatchPreference checks if selected tracks match the stored preference
 func (m *Manager) tracksMatchPreference(audio *AudioStream, subtitle *SubtitleStream, pref *database.PlexAutoLanguagesPreference) bool {
 	if pref == nil {