update

core/scrobbler/buffered_scrobbler.go

@@ -0,0 +1,133 @@
+package scrobbler
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+func newBufferedScrobbler(ds model.DataStore, s Scrobbler, service string) *bufferedScrobbler {
+	ctx, cancel := context.WithCancel(context.Background())
+	b := &bufferedScrobbler{
+		ds:         ds,
+		wrapped:    s,
+		service:    service,
+		wakeSignal: make(chan struct{}, 1),
+		ctx:        ctx,
+		cancel:     cancel,
+	}
+	go b.run(ctx)
+	return b
+}
+
+type bufferedScrobbler struct {
+	ds         model.DataStore
+	wrapped    Scrobbler
+	service    string
+	wakeSignal chan struct{}
+	ctx        context.Context
+	cancel     context.CancelFunc
+}
+
+func (b *bufferedScrobbler) Stop() {
+	if b.cancel != nil {
+		b.cancel()
+	}
+}
+
+func (b *bufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
+	return b.wrapped.IsAuthorized(ctx, userId)
+}
+
+func (b *bufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
+	return b.wrapped.NowPlaying(ctx, userId, track, position)
+}
+
+func (b *bufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
+	err := b.ds.ScrobbleBuffer(ctx).Enqueue(b.service, userId, s.ID, s.TimeStamp)
+	if err != nil {
+		return err
+	}
+
+	b.sendWakeSignal()
+	return nil
+}
+
+func (b *bufferedScrobbler) sendWakeSignal() {
+	// Don't block if the previous signal was not read yet
+	select {
+	case b.wakeSignal <- struct{}{}:
+	default:
+	}
+}
+
+func (b *bufferedScrobbler) run(ctx context.Context) {
+	for {
+		if !b.processQueue(ctx) {
+			time.AfterFunc(5*time.Second, func() {
+				b.sendWakeSignal()
+			})
+		}
+		select {
+		case <-b.wakeSignal:
+			continue
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (b *bufferedScrobbler) processQueue(ctx context.Context) bool {
+	buffer := b.ds.ScrobbleBuffer(ctx)
+	userIds, err := buffer.UserIDs(b.service)
+	if err != nil {
+		log.Error(ctx, "Error retrieving userIds from scrobble buffer", "scrobbler", b.service, err)
+		return false
+	}
+	result := true
+	for _, userId := range userIds {
+		if !b.processUserQueue(ctx, userId) {
+			result = false
+		}
+	}
+	return result
+}
+
+func (b *bufferedScrobbler) processUserQueue(ctx context.Context, userId string) bool {
+	buffer := b.ds.ScrobbleBuffer(ctx)
+	for {
+		entry, err := buffer.Next(b.service, userId)
+		if err != nil {
+			log.Error(ctx, "Error reading from scrobble buffer", "scrobbler", b.service, err)
+			return false
+		}
+		if entry == nil {
+			return true
+		}
+		log.Debug(ctx, "Sending scrobble", "scrobbler", b.service, "track", entry.Title, "artist", entry.Artist)
+		err = b.wrapped.Scrobble(ctx, entry.UserID, Scrobble{
+			MediaFile: entry.MediaFile,
+			TimeStamp: entry.PlayTime,
+		})
+		if errors.Is(err, ErrRetryLater) {
+			log.Warn(ctx, "Could not send scrobble. Will be retried", "userId", entry.UserID,
+				"track", entry.Title, "artist", entry.Artist, "scrobbler", b.service, err)
+			return false
+		}
+		if err != nil {
+			log.Error(ctx, "Error sending scrobble to service. Discarding", "scrobbler", b.service,
+				"userId", entry.UserID, "artist", entry.Artist, "track", entry.Title, err)
+		}
+		err = buffer.Dequeue(entry)
+		if err != nil {
+			log.Error(ctx, "Error removing entry from scrobble buffer", "userId", entry.UserID,
+				"track", entry.Title, "artist", entry.Artist, "scrobbler", b.service, err)
+			return false
+		}
+	}
+}
+
+var _ Scrobbler = (*bufferedScrobbler)(nil)

core/scrobbler/buffered_scrobbler_test.go

@@ -0,0 +1,89 @@
+package scrobbler
+
+import (
+	"context"
+	"time"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("BufferedScrobbler", func() {
+	var ds model.DataStore
+	var scr *fakeScrobbler
+	var bs *bufferedScrobbler
+	var ctx context.Context
+	var buffer *tests.MockedScrobbleBufferRepo
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		buffer = tests.CreateMockedScrobbleBufferRepo()
+		ds = &tests.MockDataStore{
+			MockedScrobbleBuffer: buffer,
+		}
+		scr = &fakeScrobbler{Authorized: true}
+		bs = newBufferedScrobbler(ds, scr, "test")
+	})
+
+	It("forwards IsAuthorized calls", func() {
+		scr.Authorized = true
+		Expect(bs.IsAuthorized(ctx, "user1")).To(BeTrue())
+
+		scr.Authorized = false
+		Expect(bs.IsAuthorized(ctx, "user1")).To(BeFalse())
+	})
+
+	It("forwards NowPlaying calls", func() {
+		track := &model.MediaFile{ID: "123", Title: "Test Track"}
+		Expect(bs.NowPlaying(ctx, "user1", track, 0)).To(Succeed())
+		Expect(scr.GetNowPlayingCalled()).To(BeTrue())
+		Expect(scr.GetUserID()).To(Equal("user1"))
+		Expect(scr.GetTrack()).To(Equal(track))
+	})
+
+	It("enqueues scrobbles to buffer", func() {
+		track := model.MediaFile{ID: "123", Title: "Test Track"}
+		now := time.Now()
+		scrobble := Scrobble{MediaFile: track, TimeStamp: now}
+		Expect(buffer.Length()).To(Equal(int64(0)))
+		Expect(scr.ScrobbleCalled.Load()).To(BeFalse())
+
+		Expect(bs.Scrobble(ctx, "user1", scrobble)).To(Succeed())
+
+		// Wait for the background goroutine to process the scrobble.
+		// We don't check buffer.Length() here because the background goroutine
+		// may dequeue the entry before we can observe it.
+		Eventually(scr.ScrobbleCalled.Load).Should(BeTrue())
+
+		lastScrobble := scr.LastScrobble.Load()
+		Expect(lastScrobble.MediaFile.ID).To(Equal("123"))
+		Expect(lastScrobble.TimeStamp).To(BeTemporally("==", now))
+	})
+
+	It("stops the background goroutine when Stop is called", func() {
+		// Replace the real run method with one that signals when it exits
+		done := make(chan struct{})
+
+		// Start our instrumented run function that will signal when it exits
+		go func() {
+			defer close(done)
+			bs.run(bs.ctx)
+		}()
+
+		// Wait a bit to ensure the goroutine is running
+		time.Sleep(10 * time.Millisecond)
+
+		// Call the real Stop method
+		bs.Stop()
+
+		// Wait for the goroutine to exit or timeout
+		select {
+		case <-done:
+			// Success, goroutine exited
+		case <-time.After(100 * time.Millisecond):
+			Fail("Goroutine did not exit in time after Stop was called")
+		}
+	})
+})

core/scrobbler/interfaces.go

@@ -0,0 +1,28 @@
+package scrobbler
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+type Scrobble struct {
+	model.MediaFile
+	TimeStamp time.Time
+}
+
+var (
+	ErrNotAuthorized = errors.New("not authorized")
+	ErrRetryLater    = errors.New("retry later")
+	ErrUnrecoverable = errors.New("unrecoverable")
+)
+
+type Scrobbler interface {
+	IsAuthorized(ctx context.Context, userId string) bool
+	NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error
+	Scrobble(ctx context.Context, userId string, s Scrobble) error
+}
+
+type Constructor func(ds model.DataStore) Scrobbler

core/scrobbler/play_tracker.go

@@ -0,0 +1,388 @@
+package scrobbler
+
+import (
+	"context"
+	"maps"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/utils/cache"
+	"github.com/navidrome/navidrome/utils/singleton"
+)
+
+type NowPlayingInfo struct {
+	MediaFile  model.MediaFile
+	Start      time.Time
+	Position   int
+	Username   string
+	PlayerId   string
+	PlayerName string
+}
+
+type Submission struct {
+	TrackID   string
+	Timestamp time.Time
+}
+
+type nowPlayingEntry struct {
+	userId   string
+	track    *model.MediaFile
+	position int
+}
+
+type PlayTracker interface {
+	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string, position int) error
+	GetNowPlaying(ctx context.Context) ([]NowPlayingInfo, error)
+	Submit(ctx context.Context, submissions []Submission) error
+}
+
+// PluginLoader is a minimal interface for plugin manager usage in PlayTracker
+// (avoids import cycles)
+type PluginLoader interface {
+	PluginNames(capability string) []string
+	LoadScrobbler(name string) (Scrobbler, bool)
+}
+
+type playTracker struct {
+	ds                model.DataStore
+	broker            events.Broker
+	playMap           cache.SimpleCache[string, NowPlayingInfo]
+	builtinScrobblers map[string]Scrobbler
+	pluginScrobblers  map[string]Scrobbler
+	pluginLoader      PluginLoader
+	mu                sync.RWMutex
+	npQueue           map[string]nowPlayingEntry
+	npMu              sync.Mutex
+	npSignal          chan struct{}
+	shutdown          chan struct{}
+	workerDone        chan struct{}
+}
+
+func GetPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) PlayTracker {
+	return singleton.GetInstance(func() *playTracker {
+		return newPlayTracker(ds, broker, pluginManager)
+	})
+}
+
+// This constructor only exists for testing. For normal usage, the PlayTracker has to be a singleton, returned by
+// the GetPlayTracker function above
+func newPlayTracker(ds model.DataStore, broker events.Broker, pluginManager PluginLoader) *playTracker {
+	m := cache.NewSimpleCache[string, NowPlayingInfo]()
+	p := &playTracker{
+		ds:                ds,
+		playMap:           m,
+		broker:            broker,
+		builtinScrobblers: make(map[string]Scrobbler),
+		pluginScrobblers:  make(map[string]Scrobbler),
+		pluginLoader:      pluginManager,
+		npQueue:           make(map[string]nowPlayingEntry),
+		npSignal:          make(chan struct{}, 1),
+		shutdown:          make(chan struct{}),
+		workerDone:        make(chan struct{}),
+	}
+	if conf.Server.EnableNowPlaying {
+		m.OnExpiration(func(_ string, _ NowPlayingInfo) {
+			broker.SendBroadcastMessage(context.Background(), &events.NowPlayingCount{Count: m.Len()})
+		})
+	}
+
+	var enabled []string
+	for name, constructor := range constructors {
+		s := constructor(ds)
+		if s == nil {
+			log.Debug("Scrobbler not available. Missing configuration?", "name", name)
+			continue
+		}
+		enabled = append(enabled, name)
+		s = newBufferedScrobbler(ds, s, name)
+		p.builtinScrobblers[name] = s
+	}
+	log.Debug("List of builtin scrobblers enabled", "names", enabled)
+	go p.nowPlayingWorker()
+	return p
+}
+
+// stopNowPlayingWorker stops the background worker. This is primarily for testing.
+func (p *playTracker) stopNowPlayingWorker() {
+	close(p.shutdown)
+	<-p.workerDone // Wait for worker to finish
+}
+
+// pluginNamesMatchScrobblers returns true if the set of pluginNames matches the keys in pluginScrobblers
+func pluginNamesMatchScrobblers(pluginNames []string, scrobblers map[string]Scrobbler) bool {
+	if len(pluginNames) != len(scrobblers) {
+		return false
+	}
+	for _, name := range pluginNames {
+		if _, ok := scrobblers[name]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// refreshPluginScrobblers updates the pluginScrobblers map to match the current set of plugin scrobblers
+func (p *playTracker) refreshPluginScrobblers() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if p.pluginLoader == nil {
+		return
+	}
+
+	// Get the list of available plugin names
+	pluginNames := p.pluginLoader.PluginNames("Scrobbler")
+
+	// Early return if plugin names match existing scrobblers (no change)
+	if pluginNamesMatchScrobblers(pluginNames, p.pluginScrobblers) {
+		return
+	}
+
+	// Build a set of current plugins for faster lookups
+	current := make(map[string]struct{}, len(pluginNames))
+
+	// Process additions - add new plugins
+	for _, name := range pluginNames {
+		current[name] = struct{}{}
+		// Only create a new scrobbler if it doesn't exist
+		if _, exists := p.pluginScrobblers[name]; !exists {
+			s, ok := p.pluginLoader.LoadScrobbler(name)
+			if ok && s != nil {
+				p.pluginScrobblers[name] = newBufferedScrobbler(p.ds, s, name)
+			}
+		}
+	}
+
+	type stoppableScrobbler interface {
+		Scrobbler
+		Stop()
+	}
+
+	// Process removals - remove plugins that no longer exist
+	for name, scrobbler := range p.pluginScrobblers {
+		if _, exists := current[name]; !exists {
+			// If the scrobbler implements stoppableScrobbler, call Stop() before removing it
+			if stoppable, ok := scrobbler.(stoppableScrobbler); ok {
+				log.Debug("Stopping scrobbler", "name", name)
+				stoppable.Stop()
+			}
+			delete(p.pluginScrobblers, name)
+		}
+	}
+}
+
+// getActiveScrobblers refreshes plugin scrobblers, acquires a read lock,
+// combines builtin and plugin scrobblers into a new map, releases the lock,
+// and returns the combined map.
+func (p *playTracker) getActiveScrobblers() map[string]Scrobbler {
+	p.refreshPluginScrobblers()
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	combined := maps.Clone(p.builtinScrobblers)
+	maps.Copy(combined, p.pluginScrobblers)
+	return combined
+}
+
+func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string, position int) error {
+	mf, err := p.ds.MediaFile(ctx).GetWithParticipants(trackId)
+	if err != nil {
+		log.Error(ctx, "Error retrieving mediaFile", "id", trackId, err)
+		return err
+	}
+
+	user, _ := request.UserFrom(ctx)
+	info := NowPlayingInfo{
+		MediaFile:  *mf,
+		Start:      time.Now(),
+		Position:   position,
+		Username:   user.UserName,
+		PlayerId:   playerId,
+		PlayerName: playerName,
+	}
+
+	// Calculate TTL based on remaining track duration. If position exceeds track duration,
+	// remaining is set to 0 to avoid negative TTL.
+	remaining := int(mf.Duration) - position
+	if remaining < 0 {
+		remaining = 0
+	}
+	// Add 5 seconds buffer to ensure the NowPlaying info is available slightly longer than the track duration.
+	ttl := time.Duration(remaining+5) * time.Second
+	_ = p.playMap.AddWithTTL(playerId, info, ttl)
+	if conf.Server.EnableNowPlaying {
+		p.broker.SendBroadcastMessage(ctx, &events.NowPlayingCount{Count: p.playMap.Len()})
+	}
+	player, _ := request.PlayerFrom(ctx)
+	if player.ScrobbleEnabled {
+		p.enqueueNowPlaying(playerId, user.ID, mf, position)
+	}
+	return nil
+}
+
+func (p *playTracker) enqueueNowPlaying(playerId string, userId string, track *model.MediaFile, position int) {
+	p.npMu.Lock()
+	defer p.npMu.Unlock()
+	p.npQueue[playerId] = nowPlayingEntry{
+		userId:   userId,
+		track:    track,
+		position: position,
+	}
+	p.sendNowPlayingSignal()
+}
+
+func (p *playTracker) sendNowPlayingSignal() {
+	// Don't block if the previous signal was not read yet
+	select {
+	case p.npSignal <- struct{}{}:
+	default:
+	}
+}
+
+func (p *playTracker) nowPlayingWorker() {
+	defer close(p.workerDone)
+	for {
+		select {
+		case <-p.shutdown:
+			return
+		case <-time.After(time.Second):
+		case <-p.npSignal:
+		}
+
+		p.npMu.Lock()
+		if len(p.npQueue) == 0 {
+			p.npMu.Unlock()
+			continue
+		}
+
+		// Keep a copy of the entries to process and clear the queue
+		entries := p.npQueue
+		p.npQueue = make(map[string]nowPlayingEntry)
+		p.npMu.Unlock()
+
+		// Process entries without holding lock
+		for _, entry := range entries {
+			p.dispatchNowPlaying(context.Background(), entry.userId, entry.track, entry.position)
+		}
+	}
+}
+
+func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, t *model.MediaFile, position int) {
+	if t.Artist == consts.UnknownArtist {
+		log.Debug(ctx, "Ignoring external NowPlaying update for track with unknown artist", "track", t.Title, "artist", t.Artist)
+		return
+	}
+	allScrobblers := p.getActiveScrobblers()
+	for name, s := range allScrobblers {
+		if !s.IsAuthorized(ctx, userId) {
+			continue
+		}
+		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist, "position", position)
+		err := s.NowPlaying(ctx, userId, t, position)
+		if err != nil {
+			log.Error(ctx, "Error sending NowPlayingInfo", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
+			continue
+		}
+	}
+}
+
+func (p *playTracker) GetNowPlaying(_ context.Context) ([]NowPlayingInfo, error) {
+	res := p.playMap.Values()
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].Start.After(res[j].Start)
+	})
+	return res, nil
+}
+
+func (p *playTracker) Submit(ctx context.Context, submissions []Submission) error {
+	username, _ := request.UsernameFrom(ctx)
+	player, _ := request.PlayerFrom(ctx)
+	if !player.ScrobbleEnabled {
+		log.Debug(ctx, "External scrobbling disabled for this player", "player", player.Name, "ip", player.IP, "user", username)
+	}
+	event := &events.RefreshResource{}
+	success := 0
+
+	for _, s := range submissions {
+		mf, err := p.ds.MediaFile(ctx).GetWithParticipants(s.TrackID)
+		if err != nil {
+			log.Error(ctx, "Cannot find track for scrobbling", "id", s.TrackID, "user", username, err)
+			continue
+		}
+		err = p.incPlay(ctx, mf, s.Timestamp)
+		if err != nil {
+			log.Error(ctx, "Error updating play counts", "id", mf.ID, "track", mf.Title, "user", username, err)
+		} else {
+			success++
+			event.With("song", mf.ID).With("album", mf.AlbumID).With("artist", mf.AlbumArtistID)
+			log.Info(ctx, "Scrobbled", "title", mf.Title, "artist", mf.Artist, "user", username, "timestamp", s.Timestamp)
+			if player.ScrobbleEnabled {
+				p.dispatchScrobble(ctx, mf, s.Timestamp)
+			}
+		}
+	}
+
+	if success > 0 {
+		p.broker.SendMessage(ctx, event)
+	}
+	return nil
+}
+
+func (p *playTracker) incPlay(ctx context.Context, track *model.MediaFile, timestamp time.Time) error {
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		err := tx.MediaFile(ctx).IncPlayCount(track.ID, timestamp)
+		if err != nil {
+			return err
+		}
+		err = tx.Album(ctx).IncPlayCount(track.AlbumID, timestamp)
+		if err != nil {
+			return err
+		}
+		for _, artist := range track.Participants[model.RoleArtist] {
+			err = tx.Artist(ctx).IncPlayCount(artist.ID, timestamp)
+			if err != nil {
+				return err
+			}
+		}
+		if conf.Server.EnableScrobbleHistory {
+			return tx.Scrobble(ctx).RecordScrobble(track.ID, timestamp)
+		}
+		return nil
+	})
+}
+
+func (p *playTracker) dispatchScrobble(ctx context.Context, t *model.MediaFile, playTime time.Time) {
+	if t.Artist == consts.UnknownArtist {
+		log.Debug(ctx, "Ignoring external Scrobble for track with unknown artist", "track", t.Title, "artist", t.Artist)
+		return
+	}
+
+	allScrobblers := p.getActiveScrobblers()
+	u, _ := request.UserFrom(ctx)
+	scrobble := Scrobble{MediaFile: *t, TimeStamp: playTime}
+	for name, s := range allScrobblers {
+		if !s.IsAuthorized(ctx, u.ID) {
+			continue
+		}
+		log.Debug(ctx, "Buffering Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
+		err := s.Scrobble(ctx, u.ID, scrobble)
+		if err != nil {
+			log.Error(ctx, "Error sending Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
+			continue
+		}
+	}
+}
+
+var constructors map[string]Constructor
+
+func Register(name string, init Constructor) {
+	if constructors == nil {
+		constructors = make(map[string]Constructor)
+	}
+	constructors[name] = init
+}

core/scrobbler/play_tracker_test.go

@@ -0,0 +1,535 @@
+package scrobbler
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/conf/configtest"
+	"github.com/navidrome/navidrome/consts"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+// mockPluginLoader is a test implementation of PluginLoader for plugin scrobbler tests
+// Moved to top-level scope to avoid linter issues
+
+type mockPluginLoader struct {
+	mu         sync.RWMutex
+	names      []string
+	scrobblers map[string]Scrobbler
+}
+
+func (m *mockPluginLoader) PluginNames(service string) []string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.names
+}
+
+func (m *mockPluginLoader) SetNames(names []string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.names = names
+}
+
+func (m *mockPluginLoader) LoadScrobbler(name string) (Scrobbler, bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	s, ok := m.scrobblers[name]
+	return s, ok
+}
+
+var _ = Describe("PlayTracker", func() {
+	var ctx context.Context
+	var ds model.DataStore
+	var tracker PlayTracker
+	var eventBroker *fakeEventBroker
+	var track model.MediaFile
+	var album model.Album
+	var artist1 model.Artist
+	var artist2 model.Artist
+	var fake *fakeScrobbler
+
+	BeforeEach(func() {
+		DeferCleanup(configtest.SetupConfig())
+		ctx = GinkgoT().Context()
+		ctx = request.WithUser(ctx, model.User{ID: "u-1"})
+		ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
+		ds = &tests.MockDataStore{}
+		fake = &fakeScrobbler{Authorized: true}
+		Register("fake", func(model.DataStore) Scrobbler {
+			return fake
+		})
+		Register("disabled", func(model.DataStore) Scrobbler {
+			return nil
+		})
+		eventBroker = &fakeEventBroker{}
+		tracker = newPlayTracker(ds, eventBroker, nil)
+		tracker.(*playTracker).builtinScrobblers["fake"] = fake // Bypass buffering for tests
+
+		track = model.MediaFile{
+			ID:             "123",
+			Title:          "Track Title",
+			Album:          "Track Album",
+			AlbumID:        "al-1",
+			TrackNumber:    1,
+			Duration:       180,
+			MbzRecordingID: "mbz-123",
+			Participants: map[model.Role]model.ParticipantList{
+				model.RoleArtist: []model.Participant{_p("ar-1", "Artist 1"), _p("ar-2", "Artist 2")},
+			},
+		}
+		_ = ds.MediaFile(ctx).Put(&track)
+		artist1 = model.Artist{ID: "ar-1"}
+		_ = ds.Artist(ctx).Put(&artist1)
+		artist2 = model.Artist{ID: "ar-2"}
+		_ = ds.Artist(ctx).Put(&artist2)
+		album = model.Album{ID: "al-1"}
+		_ = ds.Album(ctx).(*tests.MockAlbumRepo).Put(&album)
+	})
+
+	AfterEach(func() {
+		// Stop the worker goroutine to prevent data races between tests
+		tracker.(*playTracker).stopNowPlayingWorker()
+	})
+
+	It("does not register disabled scrobblers", func() {
+		Expect(tracker.(*playTracker).builtinScrobblers).To(HaveKey("fake"))
+		Expect(tracker.(*playTracker).builtinScrobblers).ToNot(HaveKey("disabled"))
+	})
+
+	Describe("NowPlaying", func() {
+		It("sends track to agent", func() {
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Eventually(func() bool { return fake.GetNowPlayingCalled() }).Should(BeTrue())
+			Expect(fake.GetUserID()).To(Equal("u-1"))
+			Expect(fake.GetTrack().ID).To(Equal("123"))
+			Expect(fake.GetTrack().Participants).To(Equal(track.Participants))
+		})
+		It("does not send track to agent if user has not authorized", func() {
+			fake.Authorized = false
+
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
+		})
+		It("does not send track to agent if player is not enabled to send scrobbles", func() {
+			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: false})
+
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
+		})
+		It("does not send track to agent if artist is unknown", func() {
+			track.Artist = consts.UnknownArtist
+
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.GetNowPlayingCalled()).To(BeFalse())
+		})
+
+		It("stores position when greater than zero", func() {
+			pos := 42
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", pos)
+			Expect(err).ToNot(HaveOccurred())
+
+			Eventually(func() int { return fake.GetPosition() }).Should(Equal(pos))
+
+			playing, err := tracker.GetNowPlaying(ctx)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(playing).To(HaveLen(1))
+			Expect(playing[0].Position).To(Equal(pos))
+		})
+
+		It("sends event with count", func() {
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			eventList := eventBroker.getEvents()
+			Expect(eventList).ToNot(BeEmpty())
+			evt, ok := eventList[0].(*events.NowPlayingCount)
+			Expect(ok).To(BeTrue())
+			Expect(evt.Count).To(Equal(1))
+		})
+
+		It("does not send event when disabled", func() {
+			conf.Server.EnableNowPlaying = false
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(eventBroker.getEvents()).To(BeEmpty())
+		})
+	})
+
+	Describe("GetNowPlaying", func() {
+		It("returns current playing music", func() {
+			track2 := track
+			track2.ID = "456"
+			_ = ds.MediaFile(ctx).Put(&track2)
+			ctx = request.WithUser(GinkgoT().Context(), model.User{UserName: "user-1"})
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			ctx = request.WithUser(GinkgoT().Context(), model.User{UserName: "user-2"})
+			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456", 0)
+
+			playing, err := tracker.GetNowPlaying(ctx)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(playing).To(HaveLen(2))
+			Expect(playing[0].PlayerId).To(Equal("player-2"))
+			Expect(playing[0].PlayerName).To(Equal("player-two"))
+			Expect(playing[0].Username).To(Equal("user-2"))
+			Expect(playing[0].MediaFile.ID).To(Equal("456"))
+
+			Expect(playing[1].PlayerId).To(Equal("player-1"))
+			Expect(playing[1].PlayerName).To(Equal("player-one"))
+			Expect(playing[1].Username).To(Equal("user-1"))
+			Expect(playing[1].MediaFile.ID).To(Equal("123"))
+		})
+	})
+
+	Describe("Expiration events", func() {
+		It("sends event when entry expires", func() {
+			info := NowPlayingInfo{MediaFile: track, Start: time.Now(), Username: "user"}
+			_ = tracker.(*playTracker).playMap.AddWithTTL("player-1", info, 10*time.Millisecond)
+			Eventually(func() int { return len(eventBroker.getEvents()) }).Should(BeNumerically(">", 0))
+			eventList := eventBroker.getEvents()
+			evt, ok := eventList[len(eventList)-1].(*events.NowPlayingCount)
+			Expect(ok).To(BeTrue())
+			Expect(evt.Count).To(Equal(0))
+		})
+
+		It("does not send event when disabled", func() {
+			conf.Server.EnableNowPlaying = false
+			tracker = newPlayTracker(ds, eventBroker, nil)
+			info := NowPlayingInfo{MediaFile: track, Start: time.Now(), Username: "user"}
+			_ = tracker.(*playTracker).playMap.AddWithTTL("player-2", info, 10*time.Millisecond)
+			Consistently(func() int { return len(eventBroker.getEvents()) }).Should(Equal(0))
+		})
+	})
+
+	Describe("Submit", func() {
+		It("sends track to agent", func() {
+			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+			ts := time.Now()
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled.Load()).To(BeTrue())
+			Expect(fake.GetUserID()).To(Equal("u-1"))
+			lastScrobble := fake.LastScrobble.Load()
+			Expect(lastScrobble.TimeStamp).To(BeTemporally("~", ts, 1*time.Second))
+			Expect(lastScrobble.ID).To(Equal("123"))
+			Expect(lastScrobble.Participants).To(Equal(track.Participants))
+		})
+
+		It("increments play counts in the DB", func() {
+			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+			ts := time.Now()
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(track.PlayCount).To(Equal(int64(1)))
+			Expect(album.PlayCount).To(Equal(int64(1)))
+
+			// It should increment play counts for all artists
+			Expect(artist1.PlayCount).To(Equal(int64(1)))
+			Expect(artist2.PlayCount).To(Equal(int64(1)))
+		})
+
+		It("does not send track to agent if user has not authorized", func() {
+			fake.Authorized = false
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+		})
+
+		It("does not send track to agent if player is not enabled to send scrobbles", func() {
+			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: false})
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+		})
+
+		It("does not send track to agent if artist is unknown", func() {
+			track.Artist = consts.UnknownArtist
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+		})
+
+		It("increments play counts even if it cannot scrobble", func() {
+			fake.Error = errors.New("error")
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled.Load()).To(BeFalse())
+
+			Expect(track.PlayCount).To(Equal(int64(1)))
+			Expect(album.PlayCount).To(Equal(int64(1)))
+
+			// It should increment play counts for all artists
+			Expect(artist1.PlayCount).To(Equal(int64(1)))
+			Expect(artist2.PlayCount).To(Equal(int64(1)))
+		})
+
+		Context("Scrobble History", func() {
+			It("records scrobble in repository", func() {
+				conf.Server.EnableScrobbleHistory = true
+				ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+				ts := time.Now()
+
+				err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+				Expect(err).ToNot(HaveOccurred())
+
+				mockDS := ds.(*tests.MockDataStore)
+				mockScrobble := mockDS.Scrobble(ctx).(*tests.MockScrobbleRepo)
+				Expect(mockScrobble.RecordedScrobbles).To(HaveLen(1))
+				Expect(mockScrobble.RecordedScrobbles[0].MediaFileID).To(Equal("123"))
+				Expect(mockScrobble.RecordedScrobbles[0].UserID).To(Equal("u-1"))
+				Expect(mockScrobble.RecordedScrobbles[0].SubmissionTime).To(Equal(ts))
+			})
+
+			It("does not record scrobble when history is disabled", func() {
+				conf.Server.EnableScrobbleHistory = false
+				ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+				ts := time.Now()
+
+				err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+				Expect(err).ToNot(HaveOccurred())
+				mockDS := ds.(*tests.MockDataStore)
+				mockScrobble := mockDS.Scrobble(ctx).(*tests.MockScrobbleRepo)
+				Expect(mockScrobble.RecordedScrobbles).To(HaveLen(0))
+			})
+		})
+	})
+
+	Describe("Plugin scrobbler logic", func() {
+		var pluginLoader *mockPluginLoader
+		var pluginFake *fakeScrobbler
+
+		BeforeEach(func() {
+			pluginFake = &fakeScrobbler{Authorized: true}
+			pluginLoader = &mockPluginLoader{
+				names:      []string{"plugin1"},
+				scrobblers: map[string]Scrobbler{"plugin1": pluginFake},
+			}
+			tracker = newPlayTracker(ds, events.GetBroker(), pluginLoader)
+
+			// Bypass buffering for both built-in and plugin scrobblers
+			tracker.(*playTracker).builtinScrobblers["fake"] = fake
+			tracker.(*playTracker).pluginScrobblers["plugin1"] = pluginFake
+		})
+
+		It("registers and uses plugin scrobbler for NowPlaying", func() {
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
+		})
+
+		It("removes plugin scrobbler if not present anymore", func() {
+			// First call: plugin present
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
+			pluginFake.nowPlayingCalled.Store(false)
+			// Remove plugin
+			pluginLoader.SetNames([]string{})
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			// Should not be called since plugin was removed
+			Consistently(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeFalse())
+		})
+
+		It("calls both builtin and plugin scrobblers for NowPlaying", func() {
+			fake.nowPlayingCalled.Store(false)
+			pluginFake.nowPlayingCalled.Store(false)
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Eventually(func() bool { return fake.GetNowPlayingCalled() }).Should(BeTrue())
+			Eventually(func() bool { return pluginFake.GetNowPlayingCalled() }).Should(BeTrue())
+		})
+
+		It("calls plugin scrobbler for Submit", func() {
+			ts := time.Now()
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(pluginFake.ScrobbleCalled.Load()).To(BeTrue())
+		})
+	})
+
+	Describe("Plugin Scrobbler Management", func() {
+		var pluginScr *fakeScrobbler
+		var mockPlugin *mockPluginLoader
+		var pTracker *playTracker
+		var mockedBS *mockBufferedScrobbler
+
+		BeforeEach(func() {
+			ctx = GinkgoT().Context()
+			ctx = request.WithUser(ctx, model.User{ID: "u-1"})
+			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
+			ds = &tests.MockDataStore{}
+
+			// Setup plugin scrobbler
+			pluginScr = &fakeScrobbler{Authorized: true}
+			mockPlugin = &mockPluginLoader{
+				names:      []string{"plugin1"},
+				scrobblers: map[string]Scrobbler{"plugin1": pluginScr},
+			}
+
+			// Create a tracker with the mock plugin loader
+			pTracker = newPlayTracker(ds, events.GetBroker(), mockPlugin)
+
+			// Create a mock buffered scrobbler and explicitly cast it to Scrobbler
+			mockedBS = &mockBufferedScrobbler{
+				wrapped: pluginScr,
+			}
+			// Make sure the instance is added with its concrete type preserved
+			pTracker.pluginScrobblers["plugin1"] = mockedBS
+		})
+
+		It("calls Stop on scrobblers when removing them", func() {
+			// Change the plugin names to simulate a plugin being removed
+			mockPlugin.SetNames([]string{})
+
+			// Call refreshPluginScrobblers which should detect the removed plugin
+			pTracker.refreshPluginScrobblers()
+
+			// Verify the Stop method was called
+			Expect(mockedBS.stopCalled).To(BeTrue())
+
+			// Verify the scrobbler was removed from the map
+			Expect(pTracker.pluginScrobblers).NotTo(HaveKey("plugin1"))
+		})
+	})
+})
+
+type fakeScrobbler struct {
+	Authorized       bool
+	nowPlayingCalled atomic.Bool
+	ScrobbleCalled   atomic.Bool
+	userID           atomic.Pointer[string]
+	track            atomic.Pointer[model.MediaFile]
+	position         atomic.Int32
+	LastScrobble     atomic.Pointer[Scrobble]
+	Error            error
+}
+
+func (f *fakeScrobbler) GetNowPlayingCalled() bool {
+	return f.nowPlayingCalled.Load()
+}
+
+func (f *fakeScrobbler) GetUserID() string {
+	if p := f.userID.Load(); p != nil {
+		return *p
+	}
+	return ""
+}
+
+func (f *fakeScrobbler) GetTrack() *model.MediaFile {
+	return f.track.Load()
+}
+
+func (f *fakeScrobbler) GetPosition() int {
+	return int(f.position.Load())
+}
+
+func (f *fakeScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
+	return f.Error == nil && f.Authorized
+}
+
+func (f *fakeScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
+	f.nowPlayingCalled.Store(true)
+	if f.Error != nil {
+		return f.Error
+	}
+	f.userID.Store(&userId)
+	f.track.Store(track)
+	f.position.Store(int32(position))
+	return nil
+}
+
+func (f *fakeScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
+	f.userID.Store(&userId)
+	f.LastScrobble.Store(&s)
+	f.ScrobbleCalled.Store(true)
+	if f.Error != nil {
+		return f.Error
+	}
+	return nil
+}
+
+func _p(id, name string, sortName ...string) model.Participant {
+	p := model.Participant{Artist: model.Artist{ID: id, Name: name}}
+	if len(sortName) > 0 {
+		p.Artist.SortArtistName = sortName[0]
+	}
+	return p
+}
+
+type fakeEventBroker struct {
+	http.Handler
+	events []events.Event
+	mu     sync.Mutex
+}
+
+func (f *fakeEventBroker) SendMessage(_ context.Context, event events.Event) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.events = append(f.events, event)
+}
+
+func (f *fakeEventBroker) SendBroadcastMessage(_ context.Context, event events.Event) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.events = append(f.events, event)
+}
+
+func (f *fakeEventBroker) getEvents() []events.Event {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.events
+}
+
+var _ events.Broker = (*fakeEventBroker)(nil)
+
+// mockBufferedScrobbler used to test that Stop is called
+type mockBufferedScrobbler struct {
+	wrapped    Scrobbler
+	stopCalled bool
+}
+
+func (m *mockBufferedScrobbler) Stop() {
+	m.stopCalled = true
+}
+
+func (m *mockBufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
+	return m.wrapped.IsAuthorized(ctx, userId)
+}
+
+func (m *mockBufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile, position int) error {
+	return m.wrapped.NowPlaying(ctx, userId, track, position)
+}
+
+func (m *mockBufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
+	return m.wrapped.Scrobble(ctx, userId, s)
+}

core/scrobbler/scrobbler_suite_test.go

@@ -0,0 +1,17 @@
+package scrobbler
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestAgents(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelFatal)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Scrobbler Test Suite")
+}