feat: add log service

packages/common/src/controllers/AccountController.ts

@@ -2,7 +2,6 @@ import i18next from 'i18next';
 import { inject, injectable } from 'inversify';
 
 import { DEFAULT_FEATURES } from '../constants';
-import { logDev } from '../utils/common';
 import type { IntegrationType } from '../../types/config';
 import CheckoutService from '../services/integrations/CheckoutService';
 import AccountService, { type AccountServiceFeatures } from '../services/integrations/AccountService';
@@ -24,6 +23,7 @@ import { useAccountStore } from '../stores/AccountStore';
 import { useConfigStore } from '../stores/ConfigStore';
 import { useProfileStore } from '../stores/ProfileStore';
 import { FormValidationError } from '../errors/FormValidationError';
+import { logError } from '../logger';
 
 import WatchHistoryController from './WatchHistoryController';
 import ProfileController from './ProfileController';
@@ -68,7 +68,7 @@ export default class AccountController {
         await this.getAccount();
       }
     } catch (error: unknown) {
-      logDev('Failed to get user', error);
+      logError('AccountController', 'Failed to get user', { error });
 
       // clear the session when the token was invalid
       // don't clear the session when the error is unknown (network hiccup or something similar)
@@ -386,7 +386,12 @@ export default class AccountController {
     return !!responseData?.accessGranted;
   };
 
-  reloadSubscriptions = async ({ delay, retry }: { delay?: number; retry?: number } = { delay: 0, retry: 0 }): Promise<unknown> => {
+  reloadSubscriptions = async (
+    { delay, retry }: { delay?: number; retry?: number } = {
+      delay: 0,
+      retry: 0,
+    },
+  ): Promise<unknown> => {
     useAccountStore.setState({ loading: true });
 
     const { getAccountInfo } = useAccountStore.getState();
@@ -436,7 +441,7 @@ export default class AccountController {
         pendingOffer = offerResponse.responseData;
       }
     } catch (error: unknown) {
-      logDev('Failed to fetch the pending offer', error);
+      logError('AccountController', 'Failed to fetch the pending offer', { error });
     }
 
     // let the app know to refresh the entitlements

packages/common/src/controllers/AppController.ts

@@ -10,6 +10,7 @@ import type { Config } from '../../types/config';
 import type { CalculateIntegrationType } from '../../types/calculate-integration-type';
 import { DETERMINE_INTEGRATION_TYPE } from '../modules/types';
 import { useConfigStore } from '../stores/ConfigStore';
+import { logDebug } from '../logger';
 
 import WatchHistoryController from './WatchHistoryController';
 import FavoritesController from './FavoritesController';
@@ -63,6 +64,8 @@ export default class AppController {
   };
 
   initializeApp = async (url: string, refreshEntitlements?: () => Promise<void>) => {
+    logDebug('AppController', 'Initializing app', { url });
+
     const settings = await this.settingsService.initialize();
     const configSource = await this.settingsService.getConfigSource(settings, url);
     const config = await this.loadAndValidateConfig(configSource);

packages/common/src/controllers/EpgController.test.ts

@@ -5,6 +5,7 @@ import livePlaylistFixture from '@jwp/ott-testing/fixtures/livePlaylist.json';
 
 import EpgService from '../services/EpgService';
 import type { Playlist } from '../../types/playlist';
+import { mockService } from '../../test/mockService';
 
 import EpgController from './EpgController';
 
@@ -13,15 +14,6 @@ const livePlaylist = livePlaylistFixture as Playlist;
 const transformProgram = vi.fn();
 const fetchSchedule = vi.fn();
 
-vi.mock('@jwp/ott-common/src/modules/container', () => ({
-  getNamedModule: (type: typeof EpgService) => {
-    switch (type) {
-      case EpgService:
-        return { transformProgram, fetchSchedule };
-    }
-  },
-}));
-
 const epgController = new EpgController();
 
 const mockProgram1 = {
@@ -46,13 +38,13 @@ const mockProgram2 = {
 
 describe('epgService', () => {
   beforeEach(() => {
+    mockService(EpgService, { transformProgram, fetchSchedule });
     vi.useFakeTimers();
   });
 
   afterEach(() => {
     // must be called before `vi.useRealTimers()`
     unregister();
-    vi.restoreAllMocks();
     vi.useRealTimers();
   });
 

packages/common/src/controllers/EpgController.ts

@@ -4,16 +4,16 @@ import { injectable } from 'inversify';
 import EpgService from '../services/EpgService';
 import { EPG_TYPE } from '../constants';
 import { getNamedModule } from '../modules/container';
-import { logDev } from '../utils/common';
 import type { PlaylistItem } from '../../types/playlist';
 import type { EpgChannel, EpgProgram } from '../../types/epg';
+import { logDebug, logError, logWarn } from '../logger';
 
 export const isFulfilled = <T>(input: PromiseSettledResult<T>): input is PromiseFulfilledResult<T> => {
   if (input.status === 'fulfilled') {
     return true;
   }
 
-  logDev(`An error occurred resolving a promise: `, input.reason);
+  logError('EpgController', `An error occurred resolving a promise: `, { error: input.reason });
   return false;
 };
 
@@ -58,7 +58,7 @@ export default class EpgController {
           ?.transformProgram(program)
           // This quiets promise resolution errors in the console
           .catch((error) => {
-            logDev(error);
+            logDebug('EpgController', 'Failed to transform a program', { error, program });
             return undefined;
           }),
       ),
@@ -100,7 +100,7 @@ export default class EpgController {
     const service = getNamedModule(EpgService, scheduleType, false);
 
     if (!service) {
-      console.error(`No epg service was added for the ${scheduleType} schedule type`);
+      logWarn('EpgController', `No epg service was added for the ${scheduleType} schedule type`);
     }
 
     return service;

packages/common/src/logger.ts

@@ -0,0 +1,26 @@
+import { getAllModules } from './modules/container';
+import { LogLevel } from './services/logging/LogLevel';
+import LogTransporter from './services/logging/LogTransporter';
+
+export type LogParams = { error?: unknown; [key: string]: unknown };
+
+const wrapError = (error: unknown) => {
+  return error instanceof Error ? error : new Error(String(error));
+};
+
+export const makeLogFn =
+  (logLevel: LogLevel) =>
+  (scope: string, message: string, { error, ...extra }: LogParams = {}) => {
+    const transporters = getAllModules(LogTransporter);
+
+    // call log on all transporters, the transporters should decide to handle the call or not
+    transporters.forEach((transporter) => {
+      transporter.log(logLevel, scope, message, extra, error ? wrapError(error) : undefined);
+    });
+  };
+
+export const logDebug = makeLogFn(LogLevel.DEBUG);
+export const logInfo = makeLogFn(LogLevel.INFO);
+export const logWarn = makeLogFn(LogLevel.WARN);
+export const logError = makeLogFn(LogLevel.ERROR);
+export const logFatal = makeLogFn(LogLevel.FATAL);

packages/common/src/modules/container.ts

@@ -1,7 +1,5 @@
 import { Container, injectable, type interfaces, inject } from 'inversify';
 
-import { logDev } from '../utils/common';
-
 export const container = new Container({ defaultScope: 'Singleton', skipBaseClassChecks: true });
 
 export { injectable, inject };
@@ -17,6 +15,10 @@ export function getModule<T>(constructorFunction: interfaces.ServiceIdentifier<T
   return module;
 }
 
+export function getAllModules<T>(constructorFunction: interfaces.ServiceIdentifier<T>): T[] {
+  return container.getAll(constructorFunction);
+}
+
 export function getNamedModule<T>(constructorFunction: interfaces.ServiceIdentifier<T>, name: string | null, required: false): T | undefined;
 export function getNamedModule<T>(constructorFunction: interfaces.ServiceIdentifier<T>, name: string | null, required: true): T;
 export function getNamedModule<T>(constructorFunction: interfaces.ServiceIdentifier<T>, name: string | null): T;
@@ -40,7 +42,8 @@ export function getNamedModule<T>(constructorFunction: interfaces.ServiceIdentif
       return;
     }
 
-    logDev('Error caught while initializing service', err);
+    // log service can't be used here
+    console.error('Error caught while initializing service', err);
   }
 }
 

packages/common/src/services/ApiService.ts

@@ -11,6 +11,7 @@ import type { ContentList, GetContentSearchParams } from '../../types/content-li
 import type { AdSchedule } from '../../types/ad-schedule';
 import type { EpisodeInSeries, EpisodesRes, EpisodesWithPagination, GetSeriesParams, Series } from '../../types/series';
 import env from '../env';
+import { logError } from '../logger';
 
 // change the values below to change the property used to look up the alternate image
 enum ImageProperty {
@@ -38,7 +39,7 @@ export default class ApiService {
     const date = item[prop] as string | undefined;
 
     if (date && !isValid(new Date(date))) {
-      console.error(`Invalid "${prop}" date provided for the "${item.title}" media item`);
+      logError('ApiService', `Invalid "${prop}" date provided for the "${item.title}" media item`, { error: new Error('Invalid date') });
       return undefined;
     }
 

packages/common/src/services/FavoriteService.ts

@@ -1,13 +1,13 @@
 import { inject, injectable } from 'inversify';
-import { object, array, string } from 'yup';
+import { array, object, string } from 'yup';
 
 import type { Favorite, SerializedFavorite } from '../../types/favorite';
 import type { PlaylistItem } from '../../types/playlist';
 import type { Customer } from '../../types/account';
 import { getNamedModule } from '../modules/container';
 import { INTEGRATION_TYPE } from '../modules/types';
-import { logDev } from '../utils/common';
 import { MAX_WATCHLIST_ITEMS_COUNT } from '../constants';
+import { logError } from '../logger';
 
 import ApiService from './ApiService';
 import StorageService from './StorageService';
@@ -66,7 +66,7 @@ export default class FavoriteService {
 
       return (playlistItems || []).map((item) => this.createFavorite(item));
     } catch (error: unknown) {
-      logDev('Failed to get favorites', error);
+      logError('FavoriteService', 'Failed to get favorites', { error });
     }
 
     return [];

packages/common/src/services/SettingsService.ts

@@ -3,10 +3,10 @@ import ini from 'ini';
 import { getI18n } from 'react-i18next';
 
 import { CONFIG_FILE_STORAGE_KEY, CONFIG_QUERY_KEY, OTT_GLOBAL_PLAYER_ID } from '../constants';
-import { logDev } from '../utils/common';
 import { AppError } from '../utils/error';
 import type { Settings } from '../../types/settings';
 import env from '../env';
+import { logDebug, logWarn } from '../logger';
 
 import StorageService from './StorageService';
 
@@ -44,7 +44,7 @@ export default class SettingsService {
         return configKey;
       }
 
-      logDev(`Invalid app-config query param: ${configKey}`);
+      logWarn('SettingsService', `Invalid app-config query param: ${configKey}`);
     }
     // Yes this falls through from above to look up the stored value if the query string is invalid and that's OK
 
@@ -56,7 +56,7 @@ export default class SettingsService {
         return storedSource;
       }
 
-      logDev('Invalid stored config: ' + storedSource);
+      logWarn('SettingsService', 'Invalid stored config: ' + storedSource);
       await this.storageService.removeItem(CONFIG_FILE_STORAGE_KEY);
     }
 
@@ -78,8 +78,8 @@ export default class SettingsService {
     const settings = await fetch('/.webapp.ini')
       .then((result) => result.text())
       .then((iniString) => ini.parse(iniString) as Settings)
-      .catch((e) => {
-        logDev(e);
+      .catch((error) => {
+        logDebug('SettingsService', 'Failed to fetch or parse the ini settings', { error });
         // It's possible to not use the ini settings files, so an error doesn't have to be fatal
         return {} as Settings;
       });
@@ -106,7 +106,7 @@ export default class SettingsService {
 
     // The player key should be set if using the global ott player
     if (settings.playerId === OTT_GLOBAL_PLAYER_ID && !settings.playerLicenseKey) {
-      console.warn('Using Global OTT Player without setting player key. Some features, such as analytics, may not work correctly.');
+      logWarn('SettingsService', 'Using Global OTT Player without setting player key. Some features, such as analytics, may not work correctly.');
     }
 
     // This will result in an unusable app

packages/common/src/services/WatchHistoryService.ts

@@ -6,8 +6,8 @@ import type { SerializedWatchHistoryItem, WatchHistoryItem } from '../../types/w
 import type { Customer } from '../../types/account';
 import { getNamedModule } from '../modules/container';
 import { INTEGRATION_TYPE } from '../modules/types';
-import { logDev } from '../utils/common';
 import { MAX_WATCHLIST_ITEMS_COUNT } from '../constants';
+import { logError } from '../logger';
 
 import ApiService from './ApiService';
 import StorageService from './StorageService';
@@ -107,7 +107,7 @@ export default class WatchHistoryService {
         })
         .filter((item): item is WatchHistoryItem => Boolean(item));
     } catch (error: unknown) {
-      logDev('Failed to get watch history items', error);
+      logError('WatchHistoryService', 'Failed to get watch history items', { error });
     }
 
     return [];

packages/common/src/services/epg/JWEpgService.ts

@@ -6,7 +6,7 @@ import EpgService from '../EpgService';
 import type { PlaylistItem } from '../../../types/playlist';
 import type { EpgProgram } from '../../../types/epg';
 import { getDataOrThrow } from '../../utils/api';
-import { logDev } from '../../utils/common';
+import { logError, logWarn } from '../../logger';
 
 const AUTHENTICATION_HEADER = 'API-KEY';
 
@@ -46,7 +46,7 @@ export default class JWEpgService extends EpgService {
 
   fetchSchedule = async (item: PlaylistItem) => {
     if (!item.scheduleUrl) {
-      logDev('Tried requesting a schedule for an item with missing `scheduleUrl`', item);
+      logWarn('JWEpgService', 'Tried requesting a schedule for an item with missing `scheduleUrl`', { item });
       return undefined;
     }
 
@@ -66,7 +66,7 @@ export default class JWEpgService extends EpgService {
       return await getDataOrThrow(response);
     } catch (error: unknown) {
       if (error instanceof Error) {
-        logDev(`Fetch failed for EPG schedule: '${item.scheduleUrl}'`, error);
+        logError('JWEpgService', `Fetch failed for EPG schedule: '${item.scheduleUrl}'`, { error });
       }
     }
   };

packages/common/src/services/epg/ViewNexaEpgService.ts

@@ -4,8 +4,8 @@ import { injectable } from 'inversify';
 
 import EpgService from '../EpgService';
 import type { PlaylistItem } from '../../../types/playlist';
-import { logDev } from '../../utils/common';
 import type { EpgProgram } from '../../../types/epg';
+import { logError, logWarn } from '../../logger';
 
 const viewNexaEpgProgramSchema = object().shape({
   'episode-num': object().shape({
@@ -48,7 +48,7 @@ export default class ViewNexaEpgService extends EpgService {
     const scheduleUrl = item.scheduleUrl;
 
     if (!scheduleUrl) {
-      logDev('Tried requesting a schedule for an item with missing `scheduleUrl`', item);
+      logWarn('ViewNexaEpgService', 'Tried requesting a schedule for an item with missing `scheduleUrl`', { item });
       return undefined;
     }
 
@@ -65,7 +65,7 @@ export default class ViewNexaEpgService extends EpgService {
       return schedule?.tv?.programme || [];
     } catch (error: unknown) {
       if (error instanceof Error) {
-        logDev(`Fetch failed for View Nexa EPG schedule: '${scheduleUrl}'`, error);
+        logError('ViewNexaEpgService', `Fetch failed for View Nexa EPG schedule: '${scheduleUrl}'`, { error });
       }
     }
   };