refactor(core): Use typedi to manage EventBus singletons (no-changelog) (#5795)

packages/cli/src/eventbus/MessageEventBusWriter/MessageEventBusLogWriter.ts

@@ -1,14 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { isEventMessageOptions } from '../EventMessageClasses/AbstractEventMessage';
-import { UserSettings } from 'n8n-core';
+import { Service } from 'typedi';
+import { once as eventOnce } from 'events';
 import path, { parse } from 'path';
 import { Worker } from 'worker_threads';
 import { createReadStream, existsSync, rmSync } from 'fs';
 import readline from 'readline';
+import { UserSettings } from 'n8n-core';
 import { jsonParse, LoggerProxy } from 'n8n-workflow';
 import remove from 'lodash.remove';
 import config from '@/config';
+import { inTest } from '@/constants';
+import { isEventMessageOptions } from '../EventMessageClasses/AbstractEventMessage';
 import { getEventMessageObjectByType } from '../EventMessageClasses/Helpers';
 import type { EventMessageReturnMode } from '../MessageEventBus/MessageEventBus';
 import type { EventMessageTypes } from '../EventMessageClasses';
@@ -17,15 +20,6 @@ import {
 	EventMessageConfirm,
 	isEventMessageConfirm,
 } from '../EventMessageClasses/EventMessageConfirm';
-import { once as eventOnce } from 'events';
-import { inTest } from '../../constants';
-
-interface MessageEventBusLogWriterConstructorOptions {
-	logBaseName?: string;
-	logBasePath?: string;
-	keepNumberOfFiles?: number;
-	maxFileSizeInKB?: number;
-}
 
 export interface MessageEventBusLogWriterOptions {
 	logFullBasePath: string;
@@ -42,41 +36,23 @@ interface ReadMessagesFromLogFileResult {
 /**
  * MessageEventBusWriter for Files
  */
+@Service()
 export class MessageEventBusLogWriter {
-	private static instance: MessageEventBusLogWriter;
-
-	static options: Required<MessageEventBusLogWriterOptions>;
+	private options: Required<MessageEventBusLogWriterOptions>;
 
 	private _worker: Worker | undefined;
 
-	public get worker(): Worker | undefined {
-		return this._worker;
+	constructor() {
+		const { keepLogCount, logBaseName, maxFileSizeInKB } = config.get('eventBus.logWriter');
+		this.options = {
+			logFullBasePath: path.join(UserSettings.getUserN8nFolderPath(), logBaseName),
+			keepNumberOfFiles: keepLogCount,
+			maxFileSizeInKB,
+		};
 	}
 
-	/**
-	 * Instantiates the Writer and the corresponding worker thread.
-	 * To actually start logging, call startLogging() function on the instance.
-	 *
-	 * **Note** that starting to log will archive existing logs, so handle unsent events first before calling startLogging()
-	 */
-	static async getInstance(
-		options?: MessageEventBusLogWriterConstructorOptions,
-	): Promise<MessageEventBusLogWriter> {
-		if (!MessageEventBusLogWriter.instance) {
-			MessageEventBusLogWriter.instance = new MessageEventBusLogWriter();
-			MessageEventBusLogWriter.options = {
-				logFullBasePath: path.join(
-					options?.logBasePath ?? UserSettings.getUserN8nFolderPath(),
-					options?.logBaseName ?? config.getEnv('eventBus.logWriter.logBaseName'),
-				),
-				keepNumberOfFiles:
-					options?.keepNumberOfFiles ?? config.getEnv('eventBus.logWriter.keepLogCount'),
-				maxFileSizeInKB:
-					options?.maxFileSizeInKB ?? config.getEnv('eventBus.logWriter.maxFileSizeInKB'),
-			};
-			await MessageEventBusLogWriter.instance.startThread();
-		}
-		return MessageEventBusLogWriter.instance;
+	public get worker(): Worker | undefined {
+		return this._worker;
 	}
 
 	/**
@@ -98,13 +74,19 @@ export class MessageEventBusLogWriter {
 		}
 	}
 
-	private async startThread() {
+	/**
+	 * Instantiates the Writer and the corresponding worker thread.
+	 * To actually start logging, call startLogging() function on the instance.
+	 *
+	 * **Note** that starting to log will archive existing logs, so handle unsent events first before calling startLogging()
+	 */
+	async startThread() {
 		if (this.worker) {
 			await this.close();
 		}
-		await MessageEventBusLogWriter.instance.spawnThread();
+		await this.spawnThread();
 		if (this.worker) {
-			this.worker.postMessage({ command: 'initialize', data: MessageEventBusLogWriter.options });
+			this.worker.postMessage({ command: 'initialize', data: this.options });
 		}
 	}
 
@@ -120,7 +102,7 @@ export class MessageEventBusLogWriter {
 		if (this.worker) {
 			this.worker.on('messageerror', async (error) => {
 				LoggerProxy.error('Event Bus Log Writer thread error, attempting to restart...', error);
-				await MessageEventBusLogWriter.instance.startThread();
+				await this.startThread();
 			});
 			return true;
 		}
@@ -235,14 +217,14 @@ export class MessageEventBusLogWriter {
 
 	getLogFileName(counter?: number): string {
 		if (counter) {
-			return `${MessageEventBusLogWriter.options.logFullBasePath}-${counter}.log`;
+			return `${this.options.logFullBasePath}-${counter}.log`;
 		} else {
-			return `${MessageEventBusLogWriter.options.logFullBasePath}.log`;
+			return `${this.options.logFullBasePath}.log`;
 		}
 	}
 
 	cleanAllLogs() {
-		for (let i = 0; i <= MessageEventBusLogWriter.options.keepNumberOfFiles; i++) {
+		for (let i = 0; i <= this.options.keepNumberOfFiles; i++) {
 			if (existsSync(this.getLogFileName(i))) {
 				rmSync(this.getLogFileName(i));
 			}