diff --git a/README.md b/README.md
index 827c93e1f..c46f131a5 100644
--- a/README.md
+++ b/README.md
@@ -124,9 +124,9 @@
 - 🌍️ **Online**: [https://privacy.sexy](https://privacy.sexy).
 - 🖥️ **Offline**: Download directly for: [Windows](https://github.com/undergroundwires/privacy.sexy/releases/download/0.12.8/privacy.sexy-Setup-0.12.8.exe), [macOS](https://github.com/undergroundwires/privacy.sexy/releases/download/0.12.8/privacy.sexy-0.12.8.dmg), [Linux](https://github.com/undergroundwires/privacy.sexy/releases/download/0.12.8/privacy.sexy-0.12.8.AppImage). For more options, see [here](#additional-install-options).
 
-Online version does not require to run any software on your computer. Offline version has more functions such as running the scripts directly.
+For a detailed comparison of features between the desktop and web versions of privacy.sexy, see [Desktop vs. Web Features](./docs/desktop-vs-web-features.md).
 
-💡 You should apply your configuration from time to time (more than once). It would strengthen your privacy and security control because privacy.sexy and its scripts get better and stronger in every new version.
+💡 Regularly applying your configuration with privacy.sexy is recommended, especially after each new release and major operating system updates. Each version updates scripts to enhance stability, privacy, and security.
 
 [![privacy.sexy application](img/screenshot.png?raw=true )](https://privacy.sexy)
 
diff --git a/docs/desktop-vs-web-features.md b/docs/desktop-vs-web-features.md
new file mode 100644
index 000000000..22b00c18f
--- /dev/null
+++ b/docs/desktop-vs-web-features.md
@@ -0,0 +1,36 @@
+# Desktop vs. Web Features
+
+This table outlines the differences between the desktop and web versions of `privacy.sexy`.
+
+| Feature | Desktop | Web |
+| ------- |---------|-----|
+| [Usage without installation](#usage-without-installation) | 🔴 Not available | 🟢 Available |
+| [Offline usage](#offline-usage) | 🟢 Available | 🟡 Partially available |
+| [Auto-updates](#auto-updates) | 🟢 Available | 🟢 Available |
+| [Logging](#logging) | 🟢 Available | 🔴 Not available |
+| [Script execution](#script-execution) | 🟢 Available | 🔴 Not available |
+
+## Feature Descriptions
+
+### Usage without installation
+
+The web version can be used directly in a browser without any installation, whereas the desktop version requires downloading and installing the software.
+
+> **Note for Linux:** For Linux users, privacy.sexy is available as an AppImage, which is a portable format that does not require traditional installation. This means Linux users can use the desktop version without installation, similar to the web version.
+
+### Offline usage
+
+Once loaded, the web version can be used offline. The desktop version inherently supports offline usage.
+
+### Auto-updates
+
+Both versions automatically update to ensure you have the latest features and security enhancements.
+
+### Logging
+
+The desktop version supports logging of activities to aid in troubleshooting. This feature is not available in the web version.
+
+### Script execution
+
+Direct execution of scripts is possible in the desktop version, offering a more integrated experience.
+This functionality is not present in the web version due to browser limitations.
diff --git a/package-lock.json b/package-lock.json
index 0b7c15a3d..5291d00c5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -6,14 +6,14 @@
   "packages": {
     "": {
       "name": "privacy.sexy",
-      "version": "0.12.7",
+      "version": "0.12.8",
       "hasInstallScript": true,
       "dependencies": {
         "@floating-ui/vue": "^1.0.2",
         "@juggle/resize-observer": "^3.4.0",
         "ace-builds": "^1.30.0",
         "cross-fetch": "^4.0.0",
-        "electron-log": "^4.4.8",
+        "electron-log": "^5.0.0",
         "electron-progressbar": "^2.1.0",
         "electron-updater": "^6.1.4",
         "file-saver": "^2.0.5",
@@ -6699,9 +6699,12 @@
       }
     },
     "node_modules/electron-log": {
-      "version": "4.4.8",
-      "resolved": "https://registry.npmjs.org/electron-log/-/electron-log-4.4.8.tgz",
-      "integrity": "sha512-QQ4GvrXO+HkgqqEOYbi+DHL7hj5JM+nHi/j+qrN9zeeXVKy8ZABgbu4CnG+BBqDZ2+tbeq9tUC4DZfIWFU5AZA=="
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/electron-log/-/electron-log-5.0.1.tgz",
+      "integrity": "sha512-x4wnwHg00h/onWQgjmvcdLV7Mrd9TZjxNs8LmXVpqvANDf4FsSs5wLlzOykWLcaFzR3+5hdVEQ8ctmrUxgHlPA==",
+      "engines": {
+        "node": ">= 14"
+      }
     },
     "node_modules/electron-progressbar": {
       "version": "2.1.0",
@@ -24483,9 +24486,9 @@
       }
     },
     "electron-log": {
-      "version": "4.4.8",
-      "resolved": "https://registry.npmjs.org/electron-log/-/electron-log-4.4.8.tgz",
-      "integrity": "sha512-QQ4GvrXO+HkgqqEOYbi+DHL7hj5JM+nHi/j+qrN9zeeXVKy8ZABgbu4CnG+BBqDZ2+tbeq9tUC4DZfIWFU5AZA=="
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/electron-log/-/electron-log-5.0.1.tgz",
+      "integrity": "sha512-x4wnwHg00h/onWQgjmvcdLV7Mrd9TZjxNs8LmXVpqvANDf4FsSs5wLlzOykWLcaFzR3+5hdVEQ8ctmrUxgHlPA=="
     },
     "electron-progressbar": {
       "version": "2.1.0",
diff --git a/package.json b/package.json
index 591f37ee9..b783af34e 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,7 @@
     "@juggle/resize-observer": "^3.4.0",
     "ace-builds": "^1.30.0",
     "cross-fetch": "^4.0.0",
-    "electron-log": "^4.4.8",
+    "electron-log": "^5.0.0",
     "electron-progressbar": "^2.1.0",
     "electron-updater": "^6.1.4",
     "file-saver": "^2.0.5",
diff --git a/src/application/Common/Log/Logger.ts b/src/application/Common/Log/Logger.ts
new file mode 100644
index 000000000..39ed51690
--- /dev/null
+++ b/src/application/Common/Log/Logger.ts
@@ -0,0 +1,6 @@
+export interface Logger {
+  info(...params: unknown[]): void;
+  warn(...params: unknown[]): void;
+  error(...params: unknown[]): void;
+  debug(...params: unknown[]): void;
+}
diff --git a/src/application/Common/Log/LoggerFactory.ts b/src/application/Common/Log/LoggerFactory.ts
new file mode 100644
index 000000000..e1a74e3e8
--- /dev/null
+++ b/src/application/Common/Log/LoggerFactory.ts
@@ -0,0 +1,5 @@
+import { Logger } from '@/application/Common/Log/Logger';
+
+export interface LoggerFactory {
+  readonly logger: Logger;
+}
diff --git a/src/infrastructure/Log/ConsoleLogger.ts b/src/infrastructure/Log/ConsoleLogger.ts
index cb5f23eca..3a417671f 100644
--- a/src/infrastructure/Log/ConsoleLogger.ts
+++ b/src/infrastructure/Log/ConsoleLogger.ts
@@ -1,17 +1,32 @@
-import { ILogger } from './ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
-export class ConsoleLogger implements ILogger {
-  constructor(private readonly consoleProxy: Partial<Console> = console) {
+export class ConsoleLogger implements Logger {
+  constructor(private readonly consoleProxy: ConsoleLogFunctions = globalThis.console) {
     if (!consoleProxy) { // do not trust strictNullChecks for global objects
       throw new Error('missing console');
     }
   }
 
   public info(...params: unknown[]): void {
-    const logFunction = this.consoleProxy?.info;
-    if (!logFunction) {
-      throw new Error('missing "info" function');
-    }
-    logFunction.call(this.consoleProxy, ...params);
+    this.consoleProxy.info(...params);
+  }
+
+  public warn(...params: unknown[]): void {
+    this.consoleProxy.warn(...params);
+  }
+
+  public error(...params: unknown[]): void {
+    this.consoleProxy.error(...params);
   }
+
+  public debug(...params: unknown[]): void {
+    this.consoleProxy.debug(...params);
+  }
+}
+
+interface ConsoleLogFunctions extends Partial<Console> {
+  readonly info: Console['info'];
+  readonly warn: Console['warn'];
+  readonly error: Console['error'];
+  readonly debug: Console['debug'];
 }
diff --git a/src/infrastructure/Log/ElectronLogger.ts b/src/infrastructure/Log/ElectronLogger.ts
index 3c44ca802..7cbdfb148 100644
--- a/src/infrastructure/Log/ElectronLogger.ts
+++ b/src/infrastructure/Log/ElectronLogger.ts
@@ -1,17 +1,15 @@
-import { ElectronLog } from 'electron-log';
-import { ILogger } from './ILogger';
+import log from 'electron-log/main';
+import { Logger } from '@/application/Common/Log/Logger';
+import type { LogFunctions } from 'electron-log';
 
 // Using plain-function rather than class so it can be used in Electron's context-bridging.
-export function createElectronLogger(logger: Partial<ElectronLog>): ILogger {
-  if (!logger) {
-    throw new Error('missing logger');
-  }
+export function createElectronLogger(logger: LogFunctions = log): Logger {
   return {
-    info: (...params) => {
-      if (!logger.info) {
-        throw new Error('missing "info" function');
-      }
-      logger.info(...params);
-    },
+    info: (...params) => logger.info(...params),
+    debug: (...params) => logger.debug(...params),
+    warn: (...params) => logger.warn(...params),
+    error: (...params) => logger.error(...params),
   };
 }
+
+export const ElectronLogger = createElectronLogger();
diff --git a/src/infrastructure/Log/ILogger.ts b/src/infrastructure/Log/ILogger.ts
deleted file mode 100644
index 954d12720..000000000
--- a/src/infrastructure/Log/ILogger.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export interface ILogger {
-  info (...params: unknown[]): void;
-}
diff --git a/src/infrastructure/Log/ILoggerFactory.ts b/src/infrastructure/Log/ILoggerFactory.ts
deleted file mode 100644
index 0e6ba3dba..000000000
--- a/src/infrastructure/Log/ILoggerFactory.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { ILogger } from './ILogger';
-
-export interface ILoggerFactory {
-  readonly logger: ILogger;
-}
diff --git a/src/infrastructure/Log/NoopLogger.ts b/src/infrastructure/Log/NoopLogger.ts
index 54cc6f08e..e9c6e8580 100644
--- a/src/infrastructure/Log/NoopLogger.ts
+++ b/src/infrastructure/Log/NoopLogger.ts
@@ -1,5 +1,11 @@
-import { ILogger } from './ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
-export class NoopLogger implements ILogger {
+export class NoopLogger implements Logger {
   public info(): void { /* NOOP */ }
+
+  public warn(): void { /* NOOP */ }
+
+  public error(): void { /* NOOP */ }
+
+  public debug(): void { /* NOOP */ }
 }
diff --git a/src/infrastructure/Log/WindowInjectedLogger.ts b/src/infrastructure/Log/WindowInjectedLogger.ts
index 0be0b8ef2..e863cadde 100644
--- a/src/infrastructure/Log/WindowInjectedLogger.ts
+++ b/src/infrastructure/Log/WindowInjectedLogger.ts
@@ -1,8 +1,8 @@
+import { Logger } from '@/application/Common/Log/Logger';
 import { WindowVariables } from '../WindowVariables/WindowVariables';
-import { ILogger } from './ILogger';
 
-export class WindowInjectedLogger implements ILogger {
-  private readonly logger: ILogger;
+export class WindowInjectedLogger implements Logger {
+  private readonly logger: Logger;
 
   constructor(windowVariables: WindowVariables | undefined | null = window) {
     if (!windowVariables) { // do not trust strict null checks for global objects
@@ -17,4 +17,16 @@ export class WindowInjectedLogger implements ILogger {
   public info(...params: unknown[]): void {
     this.logger.info(...params);
   }
+
+  public warn(...params: unknown[]): void {
+    this.logger.warn(...params);
+  }
+
+  public debug(...params: unknown[]): void {
+    this.logger.debug(...params);
+  }
+
+  public error(...params: unknown[]): void {
+    this.logger.error(...params);
+  }
 }
diff --git a/src/infrastructure/WindowVariables/WindowVariables.ts b/src/infrastructure/WindowVariables/WindowVariables.ts
index a5a6ed24d..4d96c27cd 100644
--- a/src/infrastructure/WindowVariables/WindowVariables.ts
+++ b/src/infrastructure/WindowVariables/WindowVariables.ts
@@ -1,11 +1,11 @@
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
 /* Primary entry point for platform-specific injections */
 export interface WindowVariables {
-  readonly isDesktop?: boolean;
+  readonly isDesktop: boolean;
   readonly system?: ISystemOperations;
   readonly os?: OperatingSystem;
-  readonly log?: ILogger;
+  readonly log: Logger;
 }
diff --git a/src/presentation/bootstrapping/ClientLoggerFactory.ts b/src/presentation/bootstrapping/ClientLoggerFactory.ts
index e6b9f933f..c290103d0 100644
--- a/src/presentation/bootstrapping/ClientLoggerFactory.ts
+++ b/src/presentation/bootstrapping/ClientLoggerFactory.ts
@@ -1,15 +1,15 @@
 import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
 import { IRuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/IRuntimeEnvironment';
 import { ConsoleLogger } from '@/infrastructure/Log/ConsoleLogger';
-import { ILogger } from '@/infrastructure/Log/ILogger';
-import { ILoggerFactory } from '@/infrastructure/Log/ILoggerFactory';
+import { Logger } from '@/application/Common/Log/Logger';
+import { LoggerFactory } from '@/application/Common/Log/LoggerFactory';
 import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
 import { WindowInjectedLogger } from '@/infrastructure/Log/WindowInjectedLogger';
 
-export class ClientLoggerFactory implements ILoggerFactory {
-  public static readonly Current: ILoggerFactory = new ClientLoggerFactory();
+export class ClientLoggerFactory implements LoggerFactory {
+  public static readonly Current: LoggerFactory = new ClientLoggerFactory();
 
-  public readonly logger: ILogger;
+  public readonly logger: Logger;
 
   protected constructor(environment: IRuntimeEnvironment = RuntimeEnvironment.CurrentEnvironment) {
     if (environment.isDesktop) {
diff --git a/src/presentation/bootstrapping/DependencyProvider.ts b/src/presentation/bootstrapping/DependencyProvider.ts
index b2b4d47fb..b3c70691f 100644
--- a/src/presentation/bootstrapping/DependencyProvider.ts
+++ b/src/presentation/bootstrapping/DependencyProvider.ts
@@ -12,6 +12,7 @@ import {
 } from '@/presentation/injectionSymbols';
 import { PropertyKeys } from '@/TypeHelpers';
 import { useUserSelectionState } from '@/presentation/components/Shared/Hooks/UseUserSelectionState';
+import { useLogger } from '@/presentation/components/Shared/Hooks/UseLogger';
 
 export function provideDependencies(
   context: IApplicationContext,
@@ -57,6 +58,10 @@ export function provideDependencies(
         return useUserSelectionState(state, events);
       },
     ),
+    useLogger: (di) => di.provide(
+      InjectionKeys.useLogger,
+      useLogger,
+    ),
   };
   registerAll(Object.values(resolvers), api);
 }
diff --git a/src/presentation/bootstrapping/Modules/AppInitializationLogger.ts b/src/presentation/bootstrapping/Modules/AppInitializationLogger.ts
index 64b59756f..a0280916f 100644
--- a/src/presentation/bootstrapping/Modules/AppInitializationLogger.ts
+++ b/src/presentation/bootstrapping/Modules/AppInitializationLogger.ts
@@ -1,10 +1,10 @@
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { Bootstrapper } from '../Bootstrapper';
 import { ClientLoggerFactory } from '../ClientLoggerFactory';
 
 export class AppInitializationLogger implements Bootstrapper {
   constructor(
-    private readonly logger: ILogger = ClientLoggerFactory.Current.logger,
+    private readonly logger: Logger = ClientLoggerFactory.Current.logger,
   ) { }
 
   public async bootstrap(): Promise<void> {
diff --git a/src/presentation/components/DevToolkit/DevToolkit.vue b/src/presentation/components/DevToolkit/DevToolkit.vue
index d2759ebab..cfc592c9c 100644
--- a/src/presentation/components/DevToolkit/DevToolkit.vue
+++ b/src/presentation/components/DevToolkit/DevToolkit.vue
@@ -17,16 +17,18 @@
 
 <script lang="ts">
 import { defineComponent } from 'vue';
+import { injectKey } from '@/presentation/injectionSymbols';
 import { dumpNames } from './DumpNames';
 
 export default defineComponent({
   setup() {
+    const { log } = injectKey((keys) => keys.useLogger);
     const devActions: readonly DevAction[] = [
       {
         name: 'Log script/category names',
         handler: async () => {
           const names = await dumpNames();
-          console.log(names);
+          log.info(names);
         },
       },
     ];
diff --git a/src/presentation/components/Shared/Hooks/UseLogger.ts b/src/presentation/components/Shared/Hooks/UseLogger.ts
new file mode 100644
index 000000000..edc3a334f
--- /dev/null
+++ b/src/presentation/components/Shared/Hooks/UseLogger.ts
@@ -0,0 +1,8 @@
+import { LoggerFactory } from '@/application/Common/Log/LoggerFactory';
+import { ClientLoggerFactory } from '@/presentation/bootstrapping/ClientLoggerFactory';
+
+export function useLogger(factory: LoggerFactory = ClientLoggerFactory.Current) {
+  return {
+    log: factory.logger,
+  };
+}
diff --git a/src/presentation/electron/main/Update/AutoUpdater.ts b/src/presentation/electron/main/Update/AutoUpdater.ts
index 1713ffce1..f28c060d0 100644
--- a/src/presentation/electron/main/Update/AutoUpdater.ts
+++ b/src/presentation/electron/main/Update/AutoUpdater.ts
@@ -1,7 +1,7 @@
 import { app, dialog } from 'electron';
 import { autoUpdater, UpdateInfo } from 'electron-updater';
 import { ProgressInfo } from 'electron-builder';
-import log from 'electron-log';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 import { UpdateProgressBar } from './UpdateProgressBar';
 
 export async function handleAutoUpdate() {
@@ -23,11 +23,11 @@ function startHandlingUpdateProgress() {
       On macOS, download-progress event is not called.
       So the indeterminate progress will continue until download is finished.
     */
-    log.debug('@download-progress@\n', progress);
+    ElectronLogger.debug('@download-progress@\n', progress);
     progressBar.showProgress(progress);
   });
   autoUpdater.on('update-downloaded', async (info: UpdateInfo) => {
-    log.info('@update-downloaded@\n', info);
+    ElectronLogger.info('@update-downloaded@\n', info);
     progressBar.close();
     await handleUpdateDownloaded();
   });
diff --git a/src/presentation/electron/main/Update/ManualUpdater.ts b/src/presentation/electron/main/Update/ManualUpdater.ts
index 5c21d37fb..e91ebb5cd 100644
--- a/src/presentation/electron/main/Update/ManualUpdater.ts
+++ b/src/presentation/electron/main/Update/ManualUpdater.ts
@@ -2,12 +2,12 @@ import fs from 'fs';
 import path from 'path';
 import { app, dialog, shell } from 'electron';
 import { UpdateInfo } from 'electron-updater';
-import log from 'electron-log';
 import fetch from 'cross-fetch';
 import { ProjectInformation } from '@/domain/ProjectInformation';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { Version } from '@/domain/Version';
 import { parseProjectInformation } from '@/application/Parser/ProjectInformationParser';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 import { UpdateProgressBar } from './UpdateProgressBar';
 
 export function requiresManualUpdate(): boolean {
@@ -64,16 +64,16 @@ async function askForVisitingWebsiteForManualUpdate(): Promise<ManualDownloadDia
 }
 
 async function download(info: UpdateInfo, project: ProjectInformation) {
-  log.info('Downloading update manually');
+  ElectronLogger.info('Downloading update manually');
   const progressBar = new UpdateProgressBar();
   progressBar.showIndeterminateState();
   try {
     const filePath = `${path.dirname(app.getPath('temp'))}/privacy.sexy/${info.version}-installer.dmg`;
     const parentFolder = path.dirname(filePath);
     if (fs.existsSync(filePath)) {
-      log.info('Update is already downloaded');
+      ElectronLogger.info('Update is already downloaded');
       await fs.promises.unlink(filePath);
-      log.info(`Deleted ${filePath}`);
+      ElectronLogger.info(`Deleted ${filePath}`);
     } else {
       await fs.promises.mkdir(parentFolder, { recursive: true });
     }
@@ -99,20 +99,20 @@ async function downloadFileWithProgress(
   progressHandler: ProgressCallback,
 ) {
   // We don't download through autoUpdater as it cannot download DMG but requires distributing ZIP
-  log.info(`Fetching ${url}`);
+  ElectronLogger.info(`Fetching ${url}`);
   const response = await fetch(url);
   if (!response.ok) {
     throw Error(`Unable to download, server returned ${response.status} ${response.statusText}`);
   }
   const contentLengthString = response.headers.get('content-length');
   if (contentLengthString === null || contentLengthString === undefined) {
-    log.error('Content-Length header is missing');
+    ElectronLogger.error('Content-Length header is missing');
   }
   const contentLength = +(contentLengthString ?? 0);
   const writer = fs.createWriteStream(filePath);
-  log.info(`Writing to ${filePath}, content length: ${contentLength}`);
+  ElectronLogger.info(`Writing to ${filePath}, content length: ${contentLength}`);
   if (Number.isNaN(contentLength) || contentLength <= 0) {
-    log.error('Unknown content-length', Array.from(response.headers.entries()));
+    ElectronLogger.error('Unknown content-length', Array.from(response.headers.entries()));
     progressHandler = () => { /* do nothing */ };
   }
   const reader = getReader(response);
@@ -137,9 +137,9 @@ async function streamWithProgress(
     receivedLength += chunk.length;
     const percentage = Math.floor((receivedLength / totalLength) * 100);
     progressHandler(percentage);
-    log.debug(`Received ${receivedLength} of ${totalLength}`);
+    ElectronLogger.debug(`Received ${receivedLength} of ${totalLength}`);
   }
-  log.info('Downloaded successfully');
+  ElectronLogger.info('Downloaded successfully');
 }
 
 function getReader(response: Response): NodeJS.ReadableStream | undefined {
diff --git a/src/presentation/electron/main/Update/UpdateProgressBar.ts b/src/presentation/electron/main/Update/UpdateProgressBar.ts
index fc7899652..9b812d9a3 100644
--- a/src/presentation/electron/main/Update/UpdateProgressBar.ts
+++ b/src/presentation/electron/main/Update/UpdateProgressBar.ts
@@ -1,7 +1,7 @@
 import ProgressBar from 'electron-progressbar';
 import { ProgressInfo } from 'electron-builder';
 import { app, BrowserWindow } from 'electron';
-import log from 'electron-log';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 
 export class UpdateProgressBar {
   private progressBar: ProgressBar | undefined;
@@ -81,7 +81,7 @@ const progressBarFactory = {
         progressBar.detail = 'Download completed.';
       })
       .on('aborted', (value: number) => {
-        log.info(`progress aborted... ${value}`);
+        ElectronLogger.info(`Progress aborted... ${value}`);
       })
       .on('progress', (value: number) => {
         progressBar.detail = `${value}% ...`;
diff --git a/src/presentation/electron/main/Update/Updater.ts b/src/presentation/electron/main/Update/Updater.ts
index b75d9da56..77e788295 100644
--- a/src/presentation/electron/main/Update/Updater.ts
+++ b/src/presentation/electron/main/Update/Updater.ts
@@ -1,5 +1,5 @@
 import { autoUpdater, UpdateInfo } from 'electron-updater';
-import log from 'electron-log';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 import { handleManualUpdate, requiresManualUpdate } from './ManualUpdater';
 import { handleAutoUpdate } from './AutoUpdater';
 
@@ -8,21 +8,21 @@ interface IUpdater {
 }
 
 export function setupAutoUpdater(): IUpdater {
-  autoUpdater.logger = log;
+  autoUpdater.logger = ElectronLogger;
 
   // Disable autodownloads because "checking" and "downloading" are handled separately based on the
   // current platform and user's choice.
   autoUpdater.autoDownload = false;
 
   autoUpdater.on('error', (error: Error) => {
-    log.error('@error@\n', error);
+    ElectronLogger.error('@error@\n', error);
   });
 
   let isAlreadyHandled = false;
   autoUpdater.on('update-available', async (info: UpdateInfo) => {
-    log.info('@update-available@\n', info);
+    ElectronLogger.info('@update-available@\n', info);
     if (isAlreadyHandled) {
-      log.info('Available updates is already handled');
+      ElectronLogger.info('Available updates is already handled');
       return;
     }
     isAlreadyHandled = true;
diff --git a/src/presentation/electron/main/index.ts b/src/presentation/electron/main/index.ts
index be80f88c1..46a54da8f 100644
--- a/src/presentation/electron/main/index.ts
+++ b/src/presentation/electron/main/index.ts
@@ -3,9 +3,10 @@
 import {
   app, protocol, BrowserWindow, shell, screen,
 } from 'electron';
+import log from 'electron-log/main';
 import installExtension, { VUEJS_DEVTOOLS } from 'electron-devtools-installer';
-import log from 'electron-log';
 import { validateRuntimeSanity } from '@/infrastructure/RuntimeSanity/SanityChecks';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 import { setupAutoUpdater } from './Update/Updater';
 import {
   APP_ICON_PATH, PRELOADER_SCRIPT_PATH, RENDERER_HTML_PATH, RENDERER_URL,
@@ -23,6 +24,7 @@ protocol.registerSchemesAsPrivileged([
 ]);
 
 setupLogger();
+
 validateRuntimeSanity({
   // Metadata is used by manual updates.
   validateEnvironmentVariables: true,
@@ -89,7 +91,7 @@ app.on('ready', async () => {
     try {
       await installExtension(VUEJS_DEVTOOLS);
     } catch (e) {
-      log.error('Vue Devtools failed to install:', e.toString());
+      ElectronLogger.error('Vue Devtools failed to install:', e.toString());
     }
   }
   createWindow();
@@ -123,7 +125,7 @@ function loadApplication(window: BrowserWindow) {
     updater.checkForUpdates();
   }
   // Do not remove [WINDOW_INIT]; it's a marker used in tests.
-  log.info('[WINDOW_INIT] Main window initialized and content loading.');
+  ElectronLogger.info('[WINDOW_INIT] Main window initialized and content loading.');
 }
 
 function configureExternalsUrlsOpenBrowser(window: BrowserWindow) {
@@ -150,5 +152,7 @@ function getWindowSize(idealWidth: number, idealHeight: number) {
 }
 
 function setupLogger(): void {
+  // log.initialize(); ← We inject logger to renderer through preloader, this is not needed.
   log.transports.file.level = 'silly';
+  log.eventLogger.startLogging();
 }
diff --git a/src/presentation/electron/preload/WindowVariablesProvider.ts b/src/presentation/electron/preload/WindowVariablesProvider.ts
index 40b1a22f1..3cc5808bc 100644
--- a/src/presentation/electron/preload/WindowVariablesProvider.ts
+++ b/src/presentation/electron/preload/WindowVariablesProvider.ts
@@ -1,13 +1,12 @@
-import log from 'electron-log';
 import { createNodeSystemOperations } from '@/infrastructure/SystemOperations/NodeSystemOperations';
 import { createElectronLogger } from '@/infrastructure/Log/ElectronLogger';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { WindowVariables } from '@/infrastructure/WindowVariables/WindowVariables';
 import { convertPlatformToOs } from './NodeOsMapper';
 
 export function provideWindowVariables(
   createSystem = createNodeSystemOperations,
-  createLogger: () => ILogger = () => createElectronLogger(log),
+  createLogger: () => Logger = () => createElectronLogger(),
   convertToOs = convertPlatformToOs,
 ): WindowVariables {
   return {
diff --git a/src/presentation/electron/preload/index.ts b/src/presentation/electron/preload/index.ts
index 17c1172a1..629f7d5dc 100644
--- a/src/presentation/electron/preload/index.ts
+++ b/src/presentation/electron/preload/index.ts
@@ -1,8 +1,8 @@
 // This file is used to securely expose Electron APIs to the application.
 
 import { contextBridge } from 'electron';
-import log from 'electron-log';
 import { validateRuntimeSanity } from '@/infrastructure/RuntimeSanity/SanityChecks';
+import { ElectronLogger } from '@/infrastructure/Log/ElectronLogger';
 import { provideWindowVariables } from './WindowVariablesProvider';
 
 validateRuntimeSanity({
@@ -20,4 +20,4 @@ Object.entries(windowVariables).forEach(([key, value]) => {
 });
 
 // Do not remove [PRELOAD_INIT]; it's a marker used in tests.
-log.info('[PRELOAD_INIT] Preload script successfully initialized and executed.');
+ElectronLogger.info('[PRELOAD_INIT] Preload script successfully initialized and executed.');
diff --git a/src/presentation/injectionSymbols.ts b/src/presentation/injectionSymbols.ts
index d2f776519..0e5fcf602 100644
--- a/src/presentation/injectionSymbols.ts
+++ b/src/presentation/injectionSymbols.ts
@@ -6,6 +6,7 @@ import type { useClipboard } from '@/presentation/components/Shared/Hooks/Clipbo
 import type { useCurrentCode } from '@/presentation/components/Shared/Hooks/UseCurrentCode';
 import type { useAutoUnsubscribedEvents } from '@/presentation/components/Shared/Hooks/UseAutoUnsubscribedEvents';
 import type { useUserSelectionState } from '@/presentation/components/Shared/Hooks/UseUserSelectionState';
+import type { useLogger } from '@/presentation/components/Shared/Hooks/UseLogger';
 
 export const InjectionKeys = {
   useCollectionState: defineTransientKey<ReturnType<typeof useCollectionState>>('useCollectionState'),
@@ -15,6 +16,7 @@ export const InjectionKeys = {
   useClipboard: defineTransientKey<ReturnType<typeof useClipboard>>('useClipboard'),
   useCurrentCode: defineTransientKey<ReturnType<typeof useCurrentCode>>('useCurrentCode'),
   useUserSelectionState: defineTransientKey<ReturnType<typeof useUserSelectionState>>('useUserSelectionState'),
+  useLogger: defineTransientKey<ReturnType<typeof useLogger>>('useLogger'),
 };
 
 export interface InjectionKeyWithLifetime<T> {
diff --git a/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/app-logs.ts b/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/app-logs.ts
index e73ad9b50..bbd20e4a6 100644
--- a/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/app-logs.ts
+++ b/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/app-logs.ts
@@ -5,33 +5,28 @@ import { exists } from '../utils/io';
 import { SupportedPlatform, CURRENT_PLATFORM } from '../utils/platform';
 import { getAppName } from '../utils/npm';
 
-const LOG_FILE_NAMES = ['main', 'renderer'];
-
 export async function clearAppLogFiles(
   projectDir: string,
 ): Promise<void> {
   if (!projectDir) { throw new Error('missing project directory'); }
-  await Promise.all(LOG_FILE_NAMES.map(async (logFileName) => {
-    const logPath = await determineLogPath(projectDir, logFileName);
-    if (!logPath || !await exists(logPath)) {
-      log(`Skipping clearing logs, log file does not exist: ${logPath}.`);
-      return;
-    }
-    try {
-      await unlink(logPath);
-      log(`Successfully cleared the log file at: ${logPath}.`);
-    } catch (error) {
-      die(`Failed to clear the log file at: ${logPath}. Reason: ${error}`);
-    }
-  }));
+  const logPath = await determineLogPath(projectDir);
+  if (!logPath || !await exists(logPath)) {
+    log(`Skipping clearing logs, log file does not exist: ${logPath}.`);
+    return;
+  }
+  try {
+    await unlink(logPath);
+    log(`Successfully cleared the log file at: ${logPath}.`);
+  } catch (error) {
+    die(`Failed to clear the log file at: ${logPath}. Reason: ${error}`);
+  }
 }
 
 export async function readAppLogFile(
   projectDir: string,
-  logFileName: string,
 ): Promise<AppLogFileResult> {
   if (!projectDir) { throw new Error('missing project directory'); }
-  const logPath = await determineLogPath(projectDir, logFileName);
+  const logPath = await determineLogPath(projectDir);
   if (!logPath || !await exists(logPath)) {
     log(`No log file at: ${logPath}`, LogLevel.Warn);
     return {
@@ -52,10 +47,9 @@ interface AppLogFileResult {
 
 async function determineLogPath(
   projectDir: string,
-  logFileName: string,
 ): Promise<string> {
   if (!projectDir) { throw new Error('missing project directory'); }
-  if (!LOG_FILE_NAMES.includes(logFileName)) { throw new Error(`unknown log file name: ${logFileName}`); }
+  const logFileName = 'main.log';
   const appName = await getAppName(projectDir);
   if (!appName) {
     return die('App name not found.');
@@ -67,19 +61,19 @@ async function determineLogPath(
       if (!process.env.HOME) {
         throw new Error('HOME environment variable is not defined');
       }
-      return join(process.env.HOME, 'Library', 'Logs', appName, `${logFileName}.log`);
+      return join(process.env.HOME, 'Library', 'Logs', appName, logFileName);
     },
     [SupportedPlatform.Linux]: () => {
       if (!process.env.HOME) {
         throw new Error('HOME environment variable is not defined');
       }
-      return join(process.env.HOME, '.config', appName, 'logs', `${logFileName}.log`);
+      return join(process.env.HOME, '.config', appName, 'logs', logFileName);
     },
     [SupportedPlatform.Windows]: () => {
       if (!process.env.USERPROFILE) {
         throw new Error('USERPROFILE environment variable is not defined');
       }
-      return join(process.env.USERPROFILE, 'AppData', 'Roaming', appName, 'logs', `${logFileName}.log`);
+      return join(process.env.USERPROFILE, 'AppData', 'Roaming', appName, 'logs', logFileName);
     },
   };
   const logFilePath = logFilePaths[CURRENT_PLATFORM]?.();
diff --git a/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/check-for-errors.ts b/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/check-for-errors.ts
index 1969b0502..786aa2cf4 100644
--- a/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/check-for-errors.ts
+++ b/tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/app/check-for-errors.ts
@@ -1,4 +1,4 @@
-import { splitTextIntoLines, indentText, filterEmpty } from '../utils/text';
+import { splitTextIntoLines, indentText } from '../utils/text';
 import { log, die } from '../utils/log';
 import { readAppLogFile } from './app-logs';
 import { STDERR_IGNORE_PATTERNS } from './error-ignore-patterns';
@@ -11,8 +11,6 @@ const EXPECTED_LOG_MARKERS = [
   '[APP_INIT]',
 ];
 
-type ProcessType = 'main' | 'renderer';
-
 export async function checkForErrors(
   stderr: string,
   windowTitles: readonly string[],
@@ -31,13 +29,11 @@ async function gatherErrors(
   projectDir: string,
 ): Promise<ExecutionError[]> {
   if (!projectDir) { throw new Error('missing project directory'); }
-  const { logFileContent: mainLogs, logFilePath: mainLogFile } = await readAppLogFile(projectDir, 'main');
-  const { logFileContent: rendererLogs, logFilePath: rendererLogFile } = await readAppLogFile(projectDir, 'renderer');
-  const allLogs = filterEmpty([mainLogs, rendererLogs, stderr]).join('\n');
+  const { logFileContent: mainLogs, logFilePath: mainLogFile } = await readAppLogFile(projectDir);
+  const allLogs = [mainLogs, stderr].filter(Boolean).join('\n');
   return [
     verifyStdErr(stderr),
-    verifyApplicationLogsExist('main', mainLogs, mainLogFile),
-    verifyApplicationLogsExist('renderer', rendererLogs, rendererLogFile),
+    verifyApplicationLogsExist(mainLogs, mainLogFile),
     ...EXPECTED_LOG_MARKERS.map(
       (marker) => verifyLogMarkerExistsInLogs(allLogs, marker),
     ),
@@ -72,13 +68,12 @@ function formatError(error: ExecutionError): string {
 }
 
 function verifyApplicationLogsExist(
-  processType: ProcessType,
   logContent: string | undefined,
   logFilePath: string,
 ): ExecutionError | undefined {
   if (!logContent?.length) {
     return describeError(
-      `Missing application (${processType}) logs`,
+      'Missing application logs',
       'Application logs are empty not were not found.'
         + `\nLog path: ${logFilePath}`,
     );
diff --git a/tests/unit/infrastructure/Log/ConsoleLogger.spec.ts b/tests/unit/infrastructure/Log/ConsoleLogger.spec.ts
index bba08d091..491140448 100644
--- a/tests/unit/infrastructure/Log/ConsoleLogger.spec.ts
+++ b/tests/unit/infrastructure/Log/ConsoleLogger.spec.ts
@@ -32,21 +32,6 @@ describe('ConsoleLogger', () => {
       expect(consoleMock.callHistory[0].args).to.deep.equal(expectedParams);
     });
   });
-  describe('throws if log function is missing', () => {
-    itEachLoggingMethod((functionName, testParameters) => {
-      // arrange
-      const expectedError = `missing "${functionName}" function`;
-      const consoleMock = {} as Partial<Console>;
-      consoleMock[functionName] = undefined;
-      const logger = new ConsoleLogger(consoleMock);
-
-      // act
-      const act = () => logger[functionName](...testParameters);
-
-      // assert
-      expect(act).to.throw(expectedError);
-    });
-  });
 });
 
 class MockConsole
@@ -58,4 +43,25 @@ class MockConsole
       args,
     });
   }
+
+  public warn(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'warn',
+      args,
+    });
+  }
+
+  public debug(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'debug',
+      args,
+    });
+  }
+
+  public error(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'error',
+      args,
+    });
+  }
 }
diff --git a/tests/unit/infrastructure/Log/ElectronLogger.spec.ts b/tests/unit/infrastructure/Log/ElectronLogger.spec.ts
index bf616f746..0ab9a6e6b 100644
--- a/tests/unit/infrastructure/Log/ElectronLogger.spec.ts
+++ b/tests/unit/infrastructure/Log/ElectronLogger.spec.ts
@@ -1,42 +1,15 @@
 import { describe, expect } from 'vitest';
-import { ElectronLog } from 'electron-log';
 import { StubWithObservableMethodCalls } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
 import { createElectronLogger } from '@/infrastructure/Log/ElectronLogger';
-import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { itEachLoggingMethod } from './LoggerTestRunner';
+import type { LogFunctions } from 'electron-log';
 
 describe('ElectronLogger', () => {
-  describe('throws if logger is missing', () => {
-    itEachAbsentObjectValue((absentValue) => {
-      // arrange
-      const expectedError = 'missing logger';
-      const electronLog = absentValue as never;
-      // act
-      const act = () => createElectronLogger(electronLog);
-      // assert
-      expect(act).to.throw(expectedError);
-    }, { excludeUndefined: true });
-  });
-  describe('throws if log function is missing', () => {
-    itEachLoggingMethod((functionName, testParameters) => {
-      // arrange
-      const expectedError = `missing "${functionName}" function`;
-      const electronLogMock = {} as Partial<ElectronLog>;
-      electronLogMock[functionName] = undefined;
-      const logger = createElectronLogger(electronLogMock);
-
-      // act
-      const act = () => logger[functionName](...testParameters);
-
-      // assert
-      expect(act).to.throw(expectedError);
-    });
-  });
   describe('methods log the provided params', () => {
     itEachLoggingMethod((functionName, testParameters) => {
       // arrange
       const expectedParams = testParameters;
-      const electronLogMock = new MockElectronLog();
+      const electronLogMock = new ElectronLogStub();
       const logger = createElectronLogger(electronLogMock);
 
       // act
@@ -50,9 +23,51 @@ describe('ElectronLogger', () => {
   });
 });
 
-class MockElectronLog
-  extends StubWithObservableMethodCalls<ElectronLog>
-  implements Partial<ElectronLog> {
+class ElectronLogStub
+  extends StubWithObservableMethodCalls<LogFunctions>
+  implements LogFunctions {
+  public error(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'error',
+      args,
+    });
+  }
+
+  public warn(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'warn',
+      args,
+    });
+  }
+
+  public verbose(...args: unknown[]): void {
+    this.registerMethodCall({
+      methodName: 'verbose',
+      args,
+    });
+  }
+
+  public debug(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'debug',
+      args,
+    });
+  }
+
+  public silly(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'silly',
+      args,
+    });
+  }
+
+  public log(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'log',
+      args,
+    });
+  }
+
   public info(...args: unknown[]) {
     this.registerMethodCall({
       methodName: 'info',
diff --git a/tests/unit/infrastructure/Log/LoggerTestRunner.ts b/tests/unit/infrastructure/Log/LoggerTestRunner.ts
index ad0e91955..c1a1faa1b 100644
--- a/tests/unit/infrastructure/Log/LoggerTestRunner.ts
+++ b/tests/unit/infrastructure/Log/LoggerTestRunner.ts
@@ -1,23 +1,25 @@
 import { it } from 'vitest';
-import { FunctionKeys } from '@/TypeHelpers';
-import { ILogger } from '@/infrastructure/Log/ILogger';
-
-type TestParameters = [string, number, { some: string }];
+import { Logger } from '@/application/Common/Log/Logger';
 
 export function itEachLoggingMethod(
   handler: (
-    functionName: keyof ILogger,
-    testParameters: TestParameters,
+    functionName: keyof Logger,
+    testParameters: readonly unknown[]
   ) => void,
 ) {
-  const testParameters: TestParameters = ['test', 123, { some: 'object' }];
-  const loggerMethods: Array<FunctionKeys<ILogger>> = [
-    'info',
-  ];
-  loggerMethods
-    .forEach((functionKey) => {
+  const testScenarios: {
+    readonly [FunctionName in keyof Logger]: Parameters<Logger[FunctionName]>;
+  } = {
+    info: ['single-string'],
+    warn: ['with number', 123],
+    debug: ['with simple object', { some: 'object' }],
+    error: ['with error object', new Error('error')],
+  };
+
+  Object.entries(testScenarios)
+    .forEach(([functionKey, testParameters]) => {
       it(functionKey, () => {
-        handler(functionKey, testParameters);
+        handler(functionKey as keyof Logger, testParameters);
       });
     });
 }
diff --git a/tests/unit/infrastructure/Log/NoopLogger.spec.ts b/tests/unit/infrastructure/Log/NoopLogger.spec.ts
index 84a6e45e0..7df6fdb0e 100644
--- a/tests/unit/infrastructure/Log/NoopLogger.spec.ts
+++ b/tests/unit/infrastructure/Log/NoopLogger.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect } from 'vitest';
 import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { itEachLoggingMethod } from './LoggerTestRunner';
 
 describe('NoopLogger', () => {
@@ -8,7 +8,7 @@ describe('NoopLogger', () => {
     itEachLoggingMethod((functionName, testParameters) => {
       // arrange
       const randomParams = testParameters;
-      const logger: ILogger = new NoopLogger();
+      const logger: Logger = new NoopLogger();
 
       // act
       const act = () => logger[functionName](...randomParams);
diff --git a/tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts b/tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts
index 9a08d5330..70af3f0d7 100644
--- a/tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts
+++ b/tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts
@@ -177,10 +177,11 @@ function expectObjectOnDesktop<T>(key: keyof WindowVariables) {
   describe('does not object type when not on desktop', () => {
     itEachInvalidObjectValue((invalidObjectValue) => {
       // arrange
+      const isOnDesktop = false;
       const invalidObject = invalidObjectValue as T;
       const input: WindowVariables = {
         ...new WindowVariablesStub(),
-        isDesktop: undefined,
+        isDesktop: isOnDesktop,
         [key]: invalidObject,
       };
       // act
diff --git a/tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts b/tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts
index ae4114cc2..10cb3ad22 100644
--- a/tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts
+++ b/tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts
@@ -3,7 +3,7 @@ import {
 } from 'vitest';
 import { IRuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/IRuntimeEnvironment';
 import { ClientLoggerFactory } from '@/presentation/bootstrapping/ClientLoggerFactory';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { WindowInjectedLogger } from '@/infrastructure/Log/WindowInjectedLogger';
 import { ConsoleLogger } from '@/infrastructure/Log/ConsoleLogger';
 import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
@@ -29,7 +29,7 @@ describe('ClientLoggerFactory', () => {
     });
     const testCases: Array<{
       readonly description: string,
-      readonly expectedType: Constructible<ILogger>,
+      readonly expectedType: Constructible<Logger>,
       readonly environment: IRuntimeEnvironment,
     }> = [
       {
diff --git a/tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts b/tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts
index 9afe3cd5f..e64a5b214 100644
--- a/tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts
+++ b/tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts
@@ -17,6 +17,7 @@ describe('DependencyProvider', () => {
       useClipboard: createTransientTests(),
       useCurrentCode: createTransientTests(),
       useUserSelectionState: createTransientTests(),
+      useLogger: createTransientTests(),
     };
     Object.entries(testCases).forEach(([key, runTests]) => {
       const registeredKey = InjectionKeys[key].key;
diff --git a/tests/unit/presentation/components/Shared/Hooks/UseLogger.spec.ts b/tests/unit/presentation/components/Shared/Hooks/UseLogger.spec.ts
new file mode 100644
index 000000000..63280f0bb
--- /dev/null
+++ b/tests/unit/presentation/components/Shared/Hooks/UseLogger.spec.ts
@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { useLogger } from '@/presentation/components/Shared/Hooks/UseLogger';
+import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
+import { LoggerFactoryStub } from '@tests/unit/shared/Stubs/LoggerFactoryStub';
+
+describe('UseLogger', () => {
+  it('returns expected logger from factory', () => {
+    // arrange
+    const expectedLogger = new LoggerStub();
+    const factory = new LoggerFactoryStub()
+      .withLogger(expectedLogger);
+    // act
+    const { log: actualLogger } = useLogger(factory);
+    // assert
+    expect(actualLogger).to.equal(expectedLogger);
+  });
+});
diff --git a/tests/unit/presentation/electron/preload/WindowVariablesProvider.spec.ts b/tests/unit/presentation/electron/preload/WindowVariablesProvider.spec.ts
index bfd938cf8..82f86a2c5 100644
--- a/tests/unit/presentation/electron/preload/WindowVariablesProvider.spec.ts
+++ b/tests/unit/presentation/electron/preload/WindowVariablesProvider.spec.ts
@@ -3,7 +3,7 @@ import { provideWindowVariables } from '@/presentation/electron/preload/WindowVa
 import { SystemOperationsStub } from '@tests/unit/shared/Stubs/SystemOperationsStub';
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
 
 describe('WindowVariablesProvider', () => {
@@ -55,7 +55,7 @@ class TestContext {
 
   private os: OperatingSystem = OperatingSystem.Android;
 
-  private log: ILogger = new LoggerStub();
+  private log: Logger = new LoggerStub();
 
   public withSystem(system: ISystemOperations): this {
     this.system = system;
@@ -67,7 +67,7 @@ class TestContext {
     return this;
   }
 
-  public withLogger(log: ILogger): this {
+  public withLogger(log: Logger): this {
     this.log = log;
     return this;
   }
diff --git a/tests/unit/shared/Stubs/LoggerFactoryStub.ts b/tests/unit/shared/Stubs/LoggerFactoryStub.ts
new file mode 100644
index 000000000..215b6b8fa
--- /dev/null
+++ b/tests/unit/shared/Stubs/LoggerFactoryStub.ts
@@ -0,0 +1,12 @@
+import { Logger } from '@/application/Common/Log/Logger';
+import { LoggerFactory } from '@/application/Common/Log/LoggerFactory';
+import { LoggerStub } from './LoggerStub';
+
+export class LoggerFactoryStub implements LoggerFactory {
+  public logger: Logger = new LoggerStub();
+
+  public withLogger(logger: Logger): this {
+    this.logger = logger;
+    return this;
+  }
+}
diff --git a/tests/unit/shared/Stubs/LoggerStub.ts b/tests/unit/shared/Stubs/LoggerStub.ts
index 970786036..0e9b752aa 100644
--- a/tests/unit/shared/Stubs/LoggerStub.ts
+++ b/tests/unit/shared/Stubs/LoggerStub.ts
@@ -1,12 +1,32 @@
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
 
-export class LoggerStub extends StubWithObservableMethodCalls<ILogger> implements ILogger {
+export class LoggerStub extends StubWithObservableMethodCalls<Logger> implements Logger {
+  public warn(...params: unknown[]): void {
+    this.registerMethodCall({
+      methodName: 'warn',
+      args: params,
+    });
+  }
+
+  public error(...params: unknown[]): void {
+    this.registerMethodCall({
+      methodName: 'error',
+      args: params,
+    });
+  }
+
+  public debug(...params: unknown[]): void {
+    this.registerMethodCall({
+      methodName: 'debug',
+      args: params,
+    });
+  }
+
   public info(...params: unknown[]): void {
     this.registerMethodCall({
       methodName: 'info',
       args: params,
     });
-    console.log(...params);
   }
 }
diff --git a/tests/unit/shared/Stubs/WindowVariablesStub.ts b/tests/unit/shared/Stubs/WindowVariablesStub.ts
index 23a803fed..78c543ace 100644
--- a/tests/unit/shared/Stubs/WindowVariablesStub.ts
+++ b/tests/unit/shared/Stubs/WindowVariablesStub.ts
@@ -1,5 +1,5 @@
 import { OperatingSystem } from '@/domain/OperatingSystem';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
 import { WindowVariables } from '@/infrastructure/WindowVariables/WindowVariables';
 import { SystemOperationsStub } from './SystemOperationsStub';
@@ -8,18 +8,18 @@ import { LoggerStub } from './LoggerStub';
 export class WindowVariablesStub implements WindowVariables {
   public system?: ISystemOperations = new SystemOperationsStub();
 
-  public isDesktop? = false;
+  public isDesktop = false;
 
   public os?: OperatingSystem = OperatingSystem.BlackBerryOS;
 
-  public log?: ILogger = new LoggerStub();
+  public log: Logger = new LoggerStub();
 
-  public withLog(log?: ILogger): this {
+  public withLog(log: Logger): this {
     this.log = log;
     return this;
   }
 
-  public withIsDesktop(value?: boolean): this {
+  public withIsDesktop(value: boolean): this {
     this.isDesktop = value;
     return this;
   }