fix(initialize): Allow custom sessions, fixes #379, closes #380 (#388)

* fix(initialize): fix session-create event missing, fixes #379 * refactor: Cosmetic changes * feat: Add getSessions and includeFutureSession preload options --------- Co-authored-by: xuewenG <[email protected]>
megahertz · Dec 24, 2023 · 0ec6d04 · 0ec6d04
1 parent 00cd210
commit 0ec6d04
Show file tree

Hide file tree

Showing 11 changed files with 146 additions and 31 deletions.
diff --git a/README.md b/README.md
@@ -30,7 +30,7 @@ Install with [npm](https://npmjs.org/package/electron-log):
 import log from 'electron-log/main';
 
 // Optional, initialize the logger for any renderer process
-log.initialize({ preload: true });
+log.initialize();
 
 log.info('Log from the main process');
 ```
@@ -44,10 +44,13 @@ import log from 'electron-log/renderer';
 log.info('Log from the renderer process');
 ```
 
+This function uses sessions to inject a preload script to make the logger
+available in a renderer process.
+
 Without a bundler, you can use a global variable `__electronLog`. It contains
 only log functions like `info`, `warn` and so on.
 
-There are a few other options how a logger can be initialized for a renderer
+There are a few other ways how a logger can be initialized for a renderer
 process. [Read more](docs/initialize.md).
 
 ### electron-log v2.x, v3.x, v4.x

diff --git a/docs/initialize.md b/docs/initialize.md
@@ -8,33 +8,42 @@ and sends it to the main process through IPC.
 
 There are a few ways how a renderer logger could be configured.
 
-## 1. Use some bundler and contextIsolation/sandbox enabled
-
-This way also works without bundler when nodeIntegration is enabled.
+## 1. Most common case. Use some bundler and contextIsolation/sandbox enabled
 
 ```js
-import log from 'electron-log';
+import log from 'electron-log/main';
 
 log.initialize();
 ````
 
 **renderer.ts**
 ```typescript
-import log from 'electron-log';
+import log from 'electron-log/renderer';
 
 log.info('Log from the renderer');
 ````
 
-If for some reason it doesn't work with your bundler, try the following
-import in the renderer process:
+This method injects a built-in preload script into a renderer process through
+sessions. The preload script is injected into the default session and any
+sessions created after a `log.initizlie()` call.
+
+### Using custom sessions
+
+If you use another session, make sure it's initialized
+after `log.initialize()` call or pass your sessions to the function:
+
+```js
+log.initialize({ getSessions: () => [customSession] });
+````
 
-`import log from 'electron-log/renderer';`
+To disable preload script injection, pass `includeFutureSession: false` option
+to the `initizlize` function.
 
 ## Use a global instance when no bundler used and nodeIntegration is disabled
 
 **main.js**
 ```js
-import log from 'electron-log';
+import log from 'electron-log/main';
 
 log.initialize();
 ````
@@ -53,7 +62,7 @@ It's possible to collect logs written by `console.log` in the renderer process
 
 **main.js**
 ```js
-import log from 'electron-log';
+import log from 'electron-log/main';
 
 // It makes a renderer logger available trough a global electronLog instance
 log.initialize({ spyRendererConsole: true });

diff --git a/e2e/custom-session/.npmrc b/e2e/custom-session/.npmrc
@@ -0,0 +1 @@
+package-lock=false
diff --git a/e2e/custom-session/index.html b/e2e/custom-session/index.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>E2E Test</title>
+  <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline';">
+</head>
+<body>
+
+<script>
+  __electronLog.info('log through global object');
+  if (window.location.href.includes('test=true')) {
+    setTimeout(() => window.close(), 50);
+  }
+</script>
+
+</body>
+</html>
diff --git a/e2e/custom-session/main.js b/e2e/custom-session/main.js
@@ -0,0 +1,27 @@
+'use strict';
+
+const { app, BrowserWindow, session } = require('electron');
+const path = require('path');
+const log = require('../..');
+
+async function createWindow() {
+  log.initialize({ preload: true });
+
+  const PARTITION = 'persist:test';
+  session.fromPartition(PARTITION);
+
+  log.info('log from the main process');
+
+  const win = new BrowserWindow({
+    webPreferences: {
+      partition: PARTITION,
+    },
+  });
+
+  const t = process.argv.includes('--test') ? 'true' : 'false';
+  await win.loadURL(`file://${path.join(__dirname, 'index.html')}?test=${t}`);
+}
+
+app
+  .on('ready', createWindow)
+  .on('window-all-closed', () => app.quit());
diff --git a/e2e/custom-session/main.spec.js b/e2e/custom-session/main.spec.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const { expect, test } = require('humile');
+const E2eApp = require('../E2eApp');
+
+const app = new E2eApp({ appPath: __dirname });
+
+test(app.appName, async () => {
+  const logReader = await app.run();
+  expect(logReader.format()).toEqual([
+    'log from the main process',
+    'log through global object',
+  ]);
+}, app.timeout);
diff --git a/e2e/custom-session/package.json b/e2e/custom-session/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "electron-log-e2e-custom-session",
+  "version": "1.0.0",
+  "private": true,
+  "main": "main.js",
+  "scripts": {
+    "start": "../../node_modules/.bin/electron ."
+  },
+  "devDependencies": {
+    "electron": "*"
+  }
+}
diff --git a/src/core/Logger.js b/src/core/Logger.js
@@ -116,8 +116,8 @@ class Logger {
     return check <= pass;
   }
 
-  initialize({ preload = true, spyRendererConsole = false } = {}) {
-    this.initializeFn({ logger: this, preload, spyRendererConsole });
+  initialize(options = {}) {
+    this.initializeFn({ logger: this, ...options });
   }
 
   logData(data, options = {}) {

diff --git a/src/index.d.ts b/src/index.d.ts
@@ -617,7 +617,12 @@ declare namespace Logger {
 
   interface MainLogger extends Logger {
     initialize(
-      options?: { preload?: string | boolean, spyRendererConsole?: boolean },
+      options?: {
+        getSessions?: () => object[];
+        includeFutureSessions?: boolean;
+        preload?: string | boolean;
+        spyRendererConsole?: boolean;
+      },
     ): void;
 
     errorHandler: ErrorHandler<MainErrorHandlerOptions>;

diff --git a/src/main/electronApi.js b/src/main/electronApi.js
@@ -59,6 +59,16 @@ module.exports = {
     };
   },
 
+  onAppReady(handler) {
+    if (electron?.app?.isReady()) {
+      handler();
+    } else if (electron?.app?.once) {
+      electron?.app?.once('ready', handler);
+    } else {
+      handler();
+    }
+  },
+
   onEveryWebContentsEvent(eventName, handler) {
     electron?.webContents?.getAllWebContents().forEach((webContents) => {
       webContents.on(eventName, handler);
@@ -103,9 +113,9 @@ module.exports = {
   setPreloadFileForSessions({
     filePath,
     includeFutureSession = true,
-    sessions = [electron?.session?.defaultSession],
+    getSessions = () => [electron?.session?.defaultSession],
   }) {
-    for (const session of sessions.filter(Boolean)) {
+    for (const session of getSessions().filter(Boolean)) {
       setPreload(session);
     }
 
@@ -142,10 +152,6 @@ module.exports = {
 
     dialog.showErrorBox(title, message);
   },
-
-  whenAppReady() {
-    return electron?.app?.whenReady() || Promise.resolve();
-  },
 };
 
 function getApp() {

diff --git a/src/main/initialize.js b/src/main/initialize.js
@@ -7,22 +7,38 @@ const electronApi = require('./electronApi');
 const preloadInitializeFn = require('../renderer/electron-log-preload');
 
 module.exports = {
-  initialize({ logger, preload = true, spyRendererConsole = false }) {
-    electronApi.whenAppReady()
-      .then(() => {
+  initialize({
+    getSessions,
+    includeFutureSession,
+    logger,
+    preload = true,
+    spyRendererConsole = false,
+  }) {
+    electronApi.onAppReady(() => {
+      try {
         if (preload) {
-          initializePreload(preload);
+          initializePreload({
+            getSessions,
+            includeFutureSession,
+            preloadOption: preload,
+          });
         }
 
         if (spyRendererConsole) {
-          initializeSpyRendererConsole(logger);
+          initializeSpyRendererConsole({ logger });
         }
-      })
-      .catch(logger.warn);
+      } catch (err) {
+        logger.warn(err);
+      }
+    });
   },
 };
 
-function initializePreload(preloadOption) {
+function initializePreload({
+  getSessions,
+  includeFutureSession,
+  preloadOption,
+}) {
   let preloadPath = typeof preloadOption === 'string'
     ? preloadOption
     : path.resolve(__dirname, '../renderer/electron-log-preload.js');
@@ -42,10 +58,14 @@ function initializePreload(preloadOption) {
     fs.writeFileSync(preloadPath, preloadCode, 'utf8');
   }
 
-  electronApi.setPreloadFileForSessions({ filePath: preloadPath });
+  electronApi.setPreloadFileForSessions({
+    filePath: preloadPath,
+    includeFutureSession,
+    getSessions,
+  });
 }
 
-function initializeSpyRendererConsole(logger) {
+function initializeSpyRendererConsole({ logger }) {
   const levels = ['verbose', 'info', 'warning', 'error'];
   electronApi.onEveryWebContentsEvent(
     'console-message',