LastFM - Fix playback check issue & improve logging

lib/Caches/AlbumCache.ts

@@ -1,8 +1,7 @@
 import { actions, store } from "@neptune";
 import type { Album } from "neptune-types/tidal";
 import { interceptPromise } from "../intercept/interceptPromise";
-import { undefinedWarn } from "../undefinedError";
-
+import { libTrace } from "../trace";
 export class AlbumCache {
 	private static readonly _cache: Record<number, Album> = {};
 	public static async get(albumId?: number) {
@@ -17,7 +16,7 @@ export class AlbumCache {
 		if (this._cache[albumId] === undefined) {
 			const album = await interceptPromise(() => actions.content.loadAlbum({ albumId }), ["content/LOAD_ALBUM_SUCCESS"], [])
 				.then((res) => <Album>res?.[0].album)
-				.catch(undefinedWarn("AlbumCache.get"));
+				.catch(libTrace.warn.withContext("AlbumCache.get"));
 			if (album !== undefined) this._cache[albumId] = album;
 		}
 

lib/Caches/ExtendedTrackItem.ts

@@ -5,8 +5,8 @@ import { MusicBrainz } from "../musicbrainzApi";
 import { Recording } from "../musicbrainzApi/types/Recording";
 import { Release } from "../musicbrainzApi/types/UPCData";
 import { TrackItemCache } from "./TrackItemCache";
-import { undefinedWarn } from "../undefinedError";
 import { AlbumCache } from "./AlbumCache";
+import { libTrace } from "../trace";
 
 export class ExtendedTrackItem {
 	public readonly trackId: ItemId;
@@ -48,14 +48,14 @@ export class ExtendedTrackItem {
 	public async recording(): Promise<Recording | undefined> {
 		if (this._recording !== undefined) return this._recording;
 
-		this._recording = await MusicBrainz.getRecording(this.trackItem()?.isrc).catch(undefinedWarn("MusicBrainz.getRecording"));
+		this._recording = await MusicBrainz.getRecording(this.trackItem()?.isrc).catch(libTrace.warn.withContext("MusicBrainz.getRecording"));
 		if (this._recording !== undefined) return this._recording;
 
 		const trackItem = this.trackItem();
 		if (trackItem === undefined) return undefined;
 
 		const releaseAlbum = await this.releaseAlbum();
-		const albumRelease = await MusicBrainz.getAlbumRelease(releaseAlbum?.id).catch(undefinedWarn("MusicBrainz.getAlbumRelease"));
+		const albumRelease = await MusicBrainz.getAlbumRelease(releaseAlbum?.id).catch(libTrace.warn.withContext("MusicBrainz.getAlbumRelease"));
 
 		const volumeNumber = (trackItem.volumeNumber ?? 1) - 1;
 		const trackNumber = (trackItem.trackNumber ?? 1) - 1;
@@ -66,7 +66,7 @@ export class ExtendedTrackItem {
 		if (this._releaseAlbum !== undefined) return this._releaseAlbum;
 
 		const album = await this.album();
-		const upcData = await MusicBrainz.getUPCData(album?.upc).catch(undefinedWarn("MusicBrainz.getUPCData"));
+		const upcData = await MusicBrainz.getUPCData(album?.upc).catch(libTrace.warn.withContext("MusicBrainz.getUPCData"));
 
 		return (this._releaseAlbum = upcData?.releases?.[0]);
 	}

lib/trace.ts

@@ -0,0 +1,64 @@
+import { actions } from "@neptune";
+import { Message, Severity } from "neptune-types/tidal";
+
+type LoggerFunc = (...data: any[]) => void;
+type MessengerFunc = (messageInfo: Message) => void;
+
+type Logger<T extends LoggerFunc = LoggerFunc> = {
+	(...data: Parameters<T>): undefined;
+	withContext(context: string): (...data: Parameters<T>) => undefined;
+};
+type Messenger = {
+	(message: unknown): undefined;
+	withContext(context: string): (message: unknown) => undefined;
+};
+
+export const Tracer = (source: string) => {
+	const createLogger = <T extends LoggerFunc>(logger: T): Logger<T> => {
+		const _logger = (...data: Parameters<T>) => {
+			logger(source, ...data);
+			return undefined;
+		};
+		_logger.withContext =
+			(context: string) =>
+			(...data: Parameters<T>) => {
+				logger(context, ...data);
+				return undefined;
+			};
+		return _logger;
+	};
+
+	const log = createLogger(console.log);
+	const warn = createLogger(console.warn);
+	const err = createLogger(console.error);
+
+	const createMessager = (logger: Logger, messager: MessengerFunc, severity: Severity): Messenger => {
+		const _messager = (message: unknown) => {
+			logger(message);
+			messager({ message: `${source} - ${message}`, category: "OTHER", severity });
+			return undefined;
+		};
+		_messager.withContext = (context: string) => {
+			const loggerWithContext = logger.withContext(context);
+			return (message: unknown) => {
+				loggerWithContext(message);
+				if (message instanceof Error) message = message.message;
+				messager({ message: `${source}.${context} - ${message}`, category: "OTHER", severity });
+				return undefined;
+			};
+		};
+		return _messager;
+	};
+
+	return {
+		log,
+		warn,
+		err,
+		msg: {
+			log: createMessager(log, actions.message.messageInfo, "INFO"),
+			warn: createMessager(warn, actions.message.messageWarn, "WARN"),
+			err: createMessager(err, actions.message.messageError, "ERROR"),
+		},
+	};
+};
+export const libTrace = Tracer("[lib]");