Do not create new logs folder each time worker is spawned

Author: Afgan0r

docs/architecture.md

@@ -94,6 +94,7 @@ Console output includes all levels with colorization (`colorize: true`, `coloriz
 2. In test environment (`NODE_ENV === 'test'`), transport is disabled — plain pino logger without file output.
 3. Log files are pre-created with `fs.ensureFileSync` to ensure target paths exist before async transport starts.
 4. Process-level handlers for `uncaughtException`, `unhandledRejection`, `SIGINT`, and `SIGTERM` write fatal logs before termination.
+5. Worker threads receive the log folder path from the main thread via `workerData.logsFolderPath`, so all workers write to the same log folder that was created at application startup instead of generating a new timestamped folder. The `workerData` shape is defined by a shared zod schema in `src/1 - replays/workers/workerData.ts`, which is used both for validation in the logger and for typing in `WorkerPool`.
 
 ## 6. Scheduler (Production Flow)
 

src/!tests/unit-tests/0 - utils/loggerWorkerData.test.ts

@@ -0,0 +1,75 @@
+import path from 'path';
+
+const logsPath = path.join(require('os').homedir(), 'sg_stats', 'logs');
+
+const importLogsFolderPath = async (
+  workerData: unknown,
+): Promise<string> => {
+  let logsFolderPathValue: string = '';
+
+  jest.isolateModules(() => {
+    jest.doMock('worker_threads', () => ({ workerData }));
+
+    // eslint-disable-next-line global-require
+    const { logsFolderPath } = require('../../../0 - utils/logger') as { logsFolderPath: string };
+
+    logsFolderPathValue = logsFolderPath;
+  });
+
+  return logsFolderPathValue;
+};
+
+describe('logger logsFolderPath in worker context', () => {
+  test('should use logsFolderPath from workerData when valid', async () => {
+    const expectedPath = '/home/user/sg_stats/logs/17.02.2026 13:00';
+
+    const result = await importLogsFolderPath({ logsFolderPath: expectedPath });
+
+    expect(result).toBe(expectedPath);
+  });
+
+  test('should not contain current timestamp when workerData has logsFolderPath', async () => {
+    const mainThreadPath = '/home/user/sg_stats/logs/01.01.2020 00:00';
+
+    const result = await importLogsFolderPath({ logsFolderPath: mainThreadPath });
+
+    expect(result).toBe(mainThreadPath);
+    expect(result).not.toContain(new Date().getFullYear().toString());
+  });
+
+  test('should generate new path when workerData is null', async () => {
+    const result = await importLogsFolderPath(null);
+
+    expect(result).not.toBe('');
+    expect(result.startsWith(logsPath)).toBe(true);
+  });
+
+  test('should generate new path when workerData is undefined', async () => {
+    const result = await importLogsFolderPath(undefined);
+
+    expect(result).not.toBe('');
+    expect(result.startsWith(logsPath)).toBe(true);
+  });
+
+  test('should generate new path when workerData has invalid shape', async () => {
+    const result = await importLogsFolderPath({ wrongField: 123 });
+
+    expect(result).not.toBe('');
+    expect(result.startsWith(logsPath)).toBe(true);
+  });
+
+  test('should generate new path when workerData has non-string logsFolderPath', async () => {
+    const result = await importLogsFolderPath({ logsFolderPath: 42 });
+
+    expect(result).not.toBe('');
+    expect(result.startsWith(logsPath)).toBe(true);
+  });
+
+  test('should use exact workerData path without appending timestamp', async () => {
+    const exactPath = '/custom/logs/fixed-folder';
+
+    const result = await importLogsFolderPath({ logsFolderPath: exactPath });
+
+    expect(result).toBe(exactPath);
+  });
+});

src/!tests/unit-tests/1 - replays, 2 - parseReplayInfo/workers/workerData.test.ts

@@ -0,0 +1,59 @@
+import { workerDataSchema, WorkerData } from '../../../../1 - replays/workers/workerData';
+
+const satisfies = <T>(value: T): T => value;
+
+describe('workerDataSchema', () => {
+  test('should accept valid workerData', () => {
+    const input = { logsFolderPath: '/home/user/sg_stats/logs/17.02.2026 13:00' };
+
+    const result = workerDataSchema.safeParse(input);
+
+    expect(result.success).toBe(true);
+
+    if (result.success) {
+      expect(result.data.logsFolderPath).toBe(input.logsFolderPath);
+    }
+  });
+
+  test('should reject when logsFolderPath is missing', () => {
+    const result = workerDataSchema.safeParse({});
+
+    expect(result.success).toBe(false);
+  });
+
+  test('should reject when logsFolderPath is not a string', () => {
+    const result = workerDataSchema.safeParse({ logsFolderPath: 123 });
+
+    expect(result.success).toBe(false);
+  });
+
+  test('should reject null', () => {
+    const result = workerDataSchema.safeParse(null);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('should reject undefined', () => {
+    const result = workerDataSchema.safeParse(undefined);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('should strip extra fields', () => {
+    const input = { logsFolderPath: '/logs/path', extra: 'value' };
+
+    const result = workerDataSchema.safeParse(input);
+
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('WorkerData type', () => {
+  test('should be assignable from valid object', () => {
+    const data = satisfies<WorkerData>({
+      logsFolderPath: '/home/user/sg_stats/logs/17.02.2026 13:00',
+    });
+
+    expect(data.logsFolderPath).toBe('/home/user/sg_stats/logs/17.02.2026 13:00');
+  });
+});

src/!tests/unit-tests/1 - replays, 2 - parseReplayInfo/workers/workerPool.test.ts

@@ -23,7 +23,8 @@ jest.mock('worker_threads', () => ({
 
     public terminate = jest.fn(async () => undefined);
 
-    constructor(scriptPath: string) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(scriptPath: string, _options?: Record<string, unknown>) {
       super();
 
       this.scriptPath = scriptPath;

src/!yearStatistics/index.ts

@@ -5,7 +5,7 @@ import fs from 'fs-extra';
 import { dayjsUTC } from '../0 - utils/dayjs';
 import generateBasicFolders from '../0 - utils/generateBasicFolders';
 import { isInInterval } from '../0 - utils/isInInterval';
-import logger from '../0 - utils/logger';
+import logger, { logsFolderPath } from '../0 - utils/logger';
 import { prepareNamesList } from '../0 - utils/namesHelper/prepareNamesList';
 import { yearResultsPath } from '../0 - utils/paths';
 import pipe from '../0 - utils/pipe';
@@ -42,6 +42,7 @@ import { printFinish } from './utils/printText';
   const workerPool = new WorkerPool({
     workerCount: 1,
     workerScriptPath: path.join(__dirname, '../1 - replays/workers/parseReplayWorker.js'),
+    workerData: { logsFolderPath },
   });
 
   logger.info(`Replays count: ${replays.length}`);

src/0 - utils/logger.ts

@@ -1,20 +1,40 @@
 import path from 'path';
+import { workerData as rawWorkerData } from 'worker_threads';
 
 import fs from 'fs-extra';
 import pino from 'pino';
 
+import { workerDataSchema } from '../1 - replays/workers/workerData';
 import { dayjsUTC } from './dayjs';
 import { dateFormat } from './namesHelper/utils/consts';
 import { logsPath } from './paths';
 
+const parseWorkerData = (): string | null => {
+  if (rawWorkerData === null || rawWorkerData === undefined) return null;
+
+  const result = workerDataSchema.safeParse(rawWorkerData);
+
+  return result.success ? result.data.logsFolderPath : null;
+};
+
 const pinoPrettyDefaultOptions = { sync: true, colorize: true, colorizeObjects: true };
 const loggerLevel = process.env.LOG_LEVEL || 'debug';
 
+const resolveLogsFolderPath = (): string => {
+  const workerLogsFolderPath = parseWorkerData();
+
+  if (workerLogsFolderPath) {
+    return workerLogsFolderPath;
+  }
+
+  return path.join(logsPath, dayjsUTC().tz('Europe/Moscow').format(dateFormat));
+};
+
+export const logsFolderPath = resolveLogsFolderPath();
+
 const getTransport = () => {
   fs.ensureDirSync(logsPath);
 
-  const logsFolderPath = path.join(logsPath, dayjsUTC().tz('Europe/Moscow').format(dateFormat));
-
   const debugFilePath = path.join(logsFolderPath, 'debug.log');
   const infoFilePath = path.join(logsFolderPath, 'info.log');
   const warningFilePath = path.join(logsFolderPath, 'warning.log');

src/1 - replays/workers/workerData.ts

@@ -0,0 +1,7 @@
+import z from 'zod';
+
+export const workerDataSchema = z.object({
+  logsFolderPath: z.string(),
+});
+
+export type WorkerData = z.infer<typeof workerDataSchema>;

src/1 - replays/workers/workerPool.ts

@@ -4,10 +4,12 @@ import {
   ParseReplayTaskMessage,
   ParseReplayTaskResponseMessage,
 } from './types';
+import { WorkerData } from './workerData';
 
 type WorkerPoolConfig = {
   workerCount: number;
   workerScriptPath: string;
+  workerData?: WorkerData;
 };
 
 type TaskWithoutId = Omit<ParseReplayTaskMessage, 'taskId'>;
@@ -30,6 +32,8 @@ const toError = (error: unknown): Error => {
 export class WorkerPool {
   private readonly workerScriptPath: string;
 
+  private readonly workerData: WorkerData | undefined;
+
   private readonly workers: Worker[] = [];
 
   private readonly queuedTasks: QueuedTask[] = [];
@@ -48,6 +52,7 @@ export class WorkerPool {
     }
 
     this.workerScriptPath = config.workerScriptPath;
+    this.workerData = config.workerData;
 
     for (let index = 0; index < config.workerCount; index += 1) {
       this.spawnWorker();
@@ -93,7 +98,10 @@ export class WorkerPool {
   }
 
   private spawnWorker(): void {
-    const worker = new Worker(this.workerScriptPath);
+    const worker = new Worker(
+      this.workerScriptPath,
+      { workerData: this.workerData },
+    );
 
     this.workers.push(worker);
     this.workerActiveTaskId.set(worker, null);

src/index.ts

@@ -7,7 +7,7 @@ import { dayjsUTC } from './0 - utils/dayjs';
 import filterPlayersByTotalPlayedGames from './0 - utils/filterPlayersByTotalPlayedGames';
 import formatGameType from './0 - utils/formatGameType';
 import generateBasicFolders from './0 - utils/generateBasicFolders';
-import logger from './0 - utils/logger';
+import logger, { logsFolderPath } from './0 - utils/logger';
 import { prepareNamesList } from './0 - utils/namesHelper/prepareNamesList';
 import {
   commitParsingStatus,
@@ -64,6 +64,7 @@ const startParsingReplays = async () => {
   const workerPool = new WorkerPool({
     workerCount: getRuntimeConfig().workerCount,
     workerScriptPath: path.join(__dirname, '1 - replays/workers/parseReplayWorker.js'),
+    workerData: { logsFolderPath },
   });
 
   logger.info('Started parsing replays.');