add and adjust some log entries

src/renderer/features/player/components/player-config.tsx

@@ -288,7 +288,6 @@ const AudioDeviceConfig = () => {
 
     return (
         <Select
-            clearable
             comboboxProps={{ withinPortal: false }}
             data={audioDevices}
             disabled={status === PlayerStatus.PLAYING}

src/renderer/features/player/context/player-context.tsx

@@ -550,8 +550,6 @@ export const PlayerProvider = ({ children }: { children: React.ReactNode }) => {
     );
 
     const getQueue = useCallback(() => {
-        logger.debug('Cleared queue');
-
         const queue = storeActions.getQueue();
         return queue.items;
     }, [storeActions]);

src/renderer/features/player/hooks/use-auto-dj.ts

@@ -64,9 +64,10 @@ export const useAutoDJ = () => {
                     return;
                 }
 
-                logger.info('Auto play triggered', {
+                logger.info('Auto DJ triggered', {
                     remaining: properties.remaining,
                     songId: properties.song?.id,
+                    songName: properties.song?.name,
                 });
 
                 try {
@@ -144,7 +145,7 @@ export const useAutoDJ = () => {
                         });
                     }
                 } catch (error) {
-                    logger.error('Auto play failed', {
+                    logger.error('Auto DJ failed', {
                         error: (error as Error).message,
                         songId: properties.song?.id,
                     });

src/renderer/features/player/hooks/use-update-current-song.ts

@@ -43,7 +43,7 @@ export const useUpdateCurrentSong = () => {
                     if (!isEqual(currentSongData, updatedSong)) {
                         updateQueueSong(currentSong.id, updatedSong);
 
-                        logger.debug('Song updated in queue', {
+                        logger.debug('Differences found, updating song in queue', {
                             id: currentSong.id,
                             name: updatedSong.name,
                         });

src/renderer/features/player/utils.ts

@@ -434,7 +434,7 @@ export const filterSongsByPlayerFilters = (songs: Song[], filters: PlayerFilter[
     });
 
     if (filteredSongs.length > 0) {
-        logger.debug('Player filters applied', {
+        logger.info('Player filters applied', {
             filteredCount: filteredSongs.length,
             filteredSongs: filteredSongs.map(({ filter, song }) => ({
                 artist: song.artistName,

src/renderer/features/radio/hooks/use-radio-player.ts

@@ -5,6 +5,7 @@ import { createWithEqualityFn } from 'zustand/traditional';
 
 import { usePlayerEvents } from '/@/renderer/features/player/audio-player/hooks/use-player-events';
 import { usePlaybackType, usePlayerStoreBase, useSettingsStore } from '/@/renderer/store';
+import { logger } from '/@/renderer/utils/logger';
 import { PlayerStatus, PlayerType } from '/@/shared/types/types';
 
 export type RadioCurrentStationArt = {
@@ -43,6 +44,7 @@ interface RadioStore {
 export const useRadioStore = createWithEqualityFn<RadioStore>((set) => ({
     actions: {
         pause: () => {
+            logger.debug('Paused radio playback');
             set({ isPlaying: false });
             usePlayerStoreBase.getState().mediaPause();
         },
@@ -68,6 +70,10 @@ export const useRadioStore = createWithEqualityFn<RadioStore>((set) => ({
                     nextStationArt = stationArt ?? null;
                 }
 
+                logger.debug('Started radio playback', {
+                    hasStationArt: Boolean(nextStationArt),
+                    stationName: newStationName,
+                });
                 usePlayerStoreBase.getState().mediaPlay();
 
                 return {
@@ -97,8 +103,10 @@ export const useRadioStore = createWithEqualityFn<RadioStore>((set) => ({
             // When stopping radio with mpv, just pause instead of calling mediaStop
             // This prevents mpv from quitting
             if (playbackType === PlayerType.LOCAL && mpvPlayer) {
+                logger.debug('Paused radio playback via mpv');
                 mpvPlayer.pause();
             } else {
+                logger.debug('Stopped radio playback');
                 usePlayerStoreBase.getState().mediaStop();
             }
         },

src/renderer/store/custom-themes.store.ts

@@ -1,6 +1,7 @@
 import isElectron from 'is-electron';
 import { create } from 'zustand';
 
+import { logger } from '/@/renderer/utils/logger';
 import { setCustomThemeRegistry } from '/@/shared/themes/app-theme';
 import { AppThemeConfiguration } from '/@/shared/themes/app-theme-types';
 
@@ -73,13 +74,26 @@ const toRegistry = (rawThemes: RawCustomTheme[]): Record<string, AppThemeConfigu
 
 export const useCustomThemesStore = create<CustomThemesActions & CustomThemesState>()((set) => ({
     openThemesFolder: async () => {
+        try {
             await customThemesApi?.openFolder();
+        } catch (error) {
+            logger.warn('Failed to open custom themes folder', { error: String(error) });
+        }
     },
     refresh: async () => {
         if (!customThemesApi) return;
+        try {
             const rawThemes = (await customThemesApi.get()) as unknown as RawCustomTheme[];
             setCustomThemeRegistry(toRegistry(rawThemes));
             set({ themes: rawThemes.map(toMeta) });
+            logger.debug('Refreshed custom themes', {
+                errorCount: rawThemes.filter((t) => t.error).length,
+                themeCount: rawThemes.length,
+                themes: rawThemes.map((t) => t.label),
+            });
+        } catch (error) {
+            logger.warn('Failed to refresh custom themes', { error: String(error) });
+        }
     },
     themes: [],
 }));

src/renderer/store/sleep-timer.store.ts

@@ -1,6 +1,8 @@
 import { useShallow } from 'zustand/react/shallow';
 import { createWithEqualityFn } from 'zustand/traditional';
 
+import { logger } from '/@/renderer/utils/logger';
+
 export type SleepTimerMode = 'endOfAlbum' | 'endOfSong' | 'timed';
 
 interface SleepTimerActions {
@@ -27,6 +29,7 @@ export const useSleepTimerStore = createWithEqualityFn<SleepTimerActions & Sleep
     (set) => ({
         active: false,
         cancelTimer: () => {
+            logger.info('Cancelled sleep timer');
             set({
                 active: false,
                 mode: 'timed',
@@ -46,6 +49,7 @@ export const useSleepTimerStore = createWithEqualityFn<SleepTimerActions & Sleep
         },
 
         startEndOfAlbumTimer: () => {
+            logger.debug('Started sleep timer', { mode: 'endOfAlbum' });
             set({
                 active: true,
                 mode: 'endOfAlbum',
@@ -55,6 +59,7 @@ export const useSleepTimerStore = createWithEqualityFn<SleepTimerActions & Sleep
         },
 
         startEndOfSongTimer: () => {
+            logger.debug('Started sleep timer', { mode: 'endOfSong' });
             set({
                 active: true,
                 mode: 'endOfSong',
@@ -64,6 +69,10 @@ export const useSleepTimerStore = createWithEqualityFn<SleepTimerActions & Sleep
         },
 
         startTimedTimer: (durationSeconds: number) => {
+            logger.debug('Started sleep timer', {
+                durationSeconds,
+                mode: 'timed',
+            });
             set({
                 active: true,
                 mode: 'timed',

src/renderer/store/utils.ts

@@ -4,6 +4,8 @@ import type { PersistStorage, StateStorage } from 'zustand/middleware';
 import { del, get, set } from 'idb-keyval';
 import mergeWith from 'lodash/mergeWith';
 
+import { logger } from '/@/renderer/utils/logger';
+
 type PlayerStorePersistedSlice = {
     player?: unknown;
     queue?: QueueData;
@@ -78,7 +80,8 @@ export const playerStoreStorage: PersistStorage<unknown> = {
         let parsed: { state?: { player?: unknown; queue?: QueueData }; version?: number };
         try {
             parsed = JSON.parse(mainRaw as string);
-        } catch {
+        } catch (error) {
+            logger.warn('Failed to parse player store', { error: String(error) });
             return null;
         }
 
@@ -89,7 +92,8 @@ export const playerStoreStorage: PersistStorage<unknown> = {
         if (queueRaw) {
             try {
                 queue = JSON.parse(queueRaw as string) as QueueData;
-            } catch {
+            } catch (error) {
+                logger.warn('Failed to parse player queue', { error: String(error) });
                 queue = undefined;
             }
         } else if (parsed.state?.queue) {
@@ -234,7 +238,9 @@ export const splitSettingsStorage: StateStorage = {
                 }
             } catch (e) {
                 // If parsing fails, continue with reading from split keys
-                console.warn('Failed to migrate old settings format:', e);
+                logger.warn('Failed to migrate old settings format', {
+                    error: String(e),
+                });
             }
         }
 
@@ -250,7 +256,10 @@ export const splitSettingsStorage: StateStorage = {
                     mergedState[keyName] = JSON.parse(value);
                     hasData = true;
                 } catch (e) {
-                    console.warn(`Failed to parse ${key}:`, e);
+                    logger.warn('Failed to parse settings key', {
+                        error: String(e),
+                        key,
+                    });
                 }
             }
         });
@@ -311,7 +320,7 @@ export const splitSettingsStorage: StateStorage = {
                 localStorage.setItem('store_settings_version', data.version.toString());
             }
         } catch (e) {
-            console.error('Failed to split settings storage:', e);
+            logger.error('Failed to split settings storage', { error: String(e) });
             localStorage.setItem(name, value);
         }
     },