@futdevpro/nts-dynamo 1.15.17 → 1.15.20

package/src/_modules/logs/file-log.service.spec.ts

@@ -0,0 +1,202 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+import { DyNTS_FileLog_Service } from './file-log.service';
+
+
+describe('| DyNTS_FileLog_Service', (): void => {
+  let tempDir: string;
+  let originalFileLogConfig: typeof DyNTS_global_settings.log_settings.file_log;
+
+  beforeEach((): void => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nts-filelog-spec-'));
+    originalFileLogConfig = DyNTS_global_settings.log_settings.file_log;
+  });
+
+  afterEach((): void => {
+    // Mindig allitsuk vissza az eredeti console-t es config-ot, hogy
+    // ne szivarogtassuk at a teszt envt.
+    DyNTS_FileLog_Service.getInstance()._teardownForTesting();
+    DyNTS_global_settings.log_settings.file_log = originalFileLogConfig;
+    try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch { /* swallow */ }
+  });
+
+  describe('| install() — gating', (): void => {
+    it('| no-op ha file_log config hianyzik', (): void => {
+      DyNTS_global_settings.log_settings.file_log = undefined;
+      DyNTS_FileLog_Service.getInstance().install();
+      expect(DyNTS_FileLog_Service.getInstance().isInstalled()).toBe(false);
+    });
+
+    it('| no-op ha enabled === false', (): void => {
+      DyNTS_global_settings.log_settings.file_log = { enabled: false, logDir: tempDir };
+      DyNTS_FileLog_Service.getInstance().install();
+      expect(DyNTS_FileLog_Service.getInstance().isInstalled()).toBe(false);
+    });
+
+    it('| install() idempotens — masodszorra is no-op', (): void => {
+      DyNTS_global_settings.log_settings.file_log = { enabled: true, logDir: tempDir };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+      const firstPath: string = svc.getCurrentLogPath();
+      svc.install();  // ismet
+      expect(svc.getCurrentLogPath()).toBe(firstPath);
+    });
+  });
+
+  describe('| install() — file creation + intercept', (): void => {
+    it('| stdout iras a fajlba is bekerul', (): void => {
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+      };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+
+      const marker: string = `hello-from-spec-${Date.now()}\n`;
+      process.stdout.write(marker);
+
+      const logPath: string = svc.getCurrentLogPath();
+      expect(fs.existsSync(logPath)).toBe(true);
+      const contents: string = fs.readFileSync(logPath, 'utf-8');
+      expect(contents).toContain(marker.trim());
+    });
+
+    it('| stderr iras a fajlba is bekerul ha includeStderr=true', (): void => {
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+      };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+
+      const marker: string = `error-marker-${Date.now()}\n`;
+      process.stderr.write(marker);
+
+      const contents: string = fs.readFileSync(svc.getCurrentLogPath(), 'utf-8');
+      expect(contents).toContain(marker.trim());
+    });
+
+    it('| ANSI escape kodok strippelve a fajlban ha stripAnsi=true (default)', (): void => {
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+      };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+
+      process.stdout.write('\x1b[31mredtext\x1b[0m-payload\n');
+
+      const contents: string = fs.readFileSync(svc.getCurrentLogPath(), 'utf-8');
+      expect(contents).toContain('redtext-payload');
+      expect(contents).not.toContain('\x1b[31m');
+      expect(contents).not.toContain('\x1b[0m');
+    });
+
+    it('| ANSI megmarad ha stripAnsi=false', (): void => {
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+        stripAnsi: false,
+      };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+
+      process.stdout.write('\x1b[31mraw\x1b[0m\n');
+
+      const contents: string = fs.readFileSync(svc.getCurrentLogPath(), 'utf-8');
+      expect(contents).toContain('\x1b[31mraw\x1b[0m');
+    });
+  });
+
+  describe('| rotation', (): void => {
+    it('| uj fajl jon letre ha az iras meghaladja a maxFileSizeMb-t', (): void => {
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'rotspec-',
+        // 1 byte limit → minden iras azonnal triggereli a rotaciot
+        maxFileSizeMb: 1 / (1024 * 1024),
+      };
+      const svc: DyNTS_FileLog_Service = DyNTS_FileLog_Service.getInstance();
+      svc.install();
+
+      const firstPath: string = svc.getCurrentLogPath();
+      process.stdout.write('payload-1\n');
+      process.stdout.write('payload-2\n');
+
+      const secondPath: string = svc.getCurrentLogPath();
+      expect(secondPath).not.toBe(firstPath);
+      // Mindket fajl letezik a tempDir-ben
+      const files: string[] = fs.readdirSync(tempDir).filter((f: string) => f.startsWith('rotspec-'));
+      expect(files.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('| retention', (): void => {
+    it('| install() torli a `retentionDays`-nel regebbi fajlokat (mtime backdated)', (): void => {
+      const oldFile: string = path.join(tempDir, 'spec-2020-01-01_00-00-00_abc.log');
+      fs.writeFileSync(oldFile, 'old');
+      const oldMs: number = Date.now() - 365 * 24 * 60 * 60 * 1000;
+      fs.utimesSync(oldFile, oldMs / 1000, oldMs / 1000);
+
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+        retentionDays: 30,
+        maxFiles: 100,  // count szabaly NE triggereljen
+      };
+      DyNTS_FileLog_Service.getInstance().install();
+
+      expect(fs.existsSync(oldFile)).toBe(false);
+    });
+
+    it('| install() retention by count — maxFiles-nel tobb fajl van, a legregebbi torlodik', (): void => {
+      // 3 fix mtime-u "regi" fajl letrehozasa (azonnali age szempontbol mind ok)
+      const now: number = Date.now();
+      const f1: string = path.join(tempDir, 'spec-2026-01-01_00-00-01_aaa.log');
+      const f2: string = path.join(tempDir, 'spec-2026-01-01_00-00-02_bbb.log');
+      const f3: string = path.join(tempDir, 'spec-2026-01-01_00-00-03_ccc.log');
+      fs.writeFileSync(f1, '1'); fs.utimesSync(f1, (now - 30000) / 1000, (now - 30000) / 1000);
+      fs.writeFileSync(f2, '2'); fs.utimesSync(f2, (now - 20000) / 1000, (now - 20000) / 1000);
+      fs.writeFileSync(f3, '3'); fs.utimesSync(f3, (now - 10000) / 1000, (now - 10000) / 1000);
+
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: tempDir,
+        filenamePrefix: 'spec-',
+        maxFiles: 2,            // a legregebbi (f1) torlodik
+        retentionDays: 36500,   // age szabaly NE triggereljen
+      };
+      DyNTS_FileLog_Service.getInstance().install();
+
+      expect(fs.existsSync(f1)).toBe(false);
+      expect(fs.existsSync(f2)).toBe(true);
+      expect(fs.existsSync(f3)).toBe(true);
+    });
+  });
+
+  describe('| silent failure', (): void => {
+    it('| install() NEM crashel ha a logDir letrehozasa bukik', (): void => {
+      // Olyan path amit nem lehet letrehozni: egy meglévő fajl ALATTI subdir.
+      const blocker: string = path.join(tempDir, 'iam-a-file');
+      fs.writeFileSync(blocker, '');
+      const impossible: string = path.join(blocker, 'cant-create-subdir');
+
+      DyNTS_global_settings.log_settings.file_log = {
+        enabled: true,
+        logDir: impossible,
+      };
+      expect(() => DyNTS_FileLog_Service.getInstance().install()).not.toThrow();
+      expect(DyNTS_FileLog_Service.getInstance().isInstalled()).toBe(false);
+    });
+  });
+});

package/src/_modules/logs/file-log.service.ts

@@ -0,0 +1,283 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { DyNTS_SingletonServiceBase } from '../../_services/base/singleton.service-base';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+
+/**
+ * Default ertekek a file-log config mezokhez. A `file_log` config nelkul
+ * az install() no-op (enabled === false).
+ */
+const DEFAULT_LOG_DIR: string = './logs/server';
+const DEFAULT_FILENAME_PREFIX: string = 'server-';
+const DEFAULT_FILENAME_SUFFIX: string = '.log';
+const DEFAULT_MAX_FILE_SIZE_MB: number = 50;
+const DEFAULT_MAX_FILES: number = 10;
+const DEFAULT_RETENTION_DAYS: number = 30;
+const DEFAULT_STRIP_ANSI: boolean = true;
+const DEFAULT_INCLUDE_STDOUT: boolean = true;
+const DEFAULT_INCLUDE_STDERR: boolean = true;
+
+/** ANSI escape code regex (szin/formazas kodok). */
+const ANSI_ESCAPE_REGEX: RegExp = /\x1b\[[0-9;]*[a-zA-Z]/g;
+
+
+/**
+ * File-based szerver log service — duplikalja a stdout/stderr-t per-session
+ * log fajl(ok)ba, miközben a console kimenet erintetlenul marad. Az
+ * in-memory ring buffer (`DyNTS_Logs_Service`) MELLETT mukodik, NEM
+ * helyette.
+ *
+ * Architecture:
+ *   - `process.stdout.write` es `process.stderr.write` monkey-patch (NEM
+ *     `console.*` — azt mar a `DyNTS_Logs_Service` patch-elheti)
+ *   - Per-session fajl: `{logDir}/{prefix}YYYY-MM-DD_HH-MM-SS.log`
+ *   - Sync `appendFileSync` iras — crash-safe, azonnali flush
+ *   - Rotation: `maxFileSizeMb` atlepesenel uj session fajl
+ *   - Retention: `maxFiles` (count) ES `retentionDays` (age) — ami elobb
+ *     teljesul; install-kor + minden rotation utan futtatva
+ *   - Silent failure: file IO hibak ELNYELODNEK (a file logger SOHASEM
+ *     buktathatja el a szervert)
+ *
+ * Idempotens: tobbszori install() hivas no-op (a masodiktol).
+ *
+ * Hasznalat:
+ *   DyNTS_global_settings.log_settings.file_log = { enabled: true, ... };
+ *   DyNTS_FileLog_Service.getInstance().install();  // szerver startup
+ */
+export class DyNTS_FileLog_Service extends DyNTS_SingletonServiceBase {
+
+  static getInstance(): DyNTS_FileLog_Service {
+    return DyNTS_FileLog_Service.getSingletonInstance() as DyNTS_FileLog_Service;
+  }
+
+  private installed: boolean = false;
+  private activeLogDir: string = '';
+  private filenamePrefix: string = DEFAULT_FILENAME_PREFIX;
+  private maxFileSizeBytes: number = DEFAULT_MAX_FILE_SIZE_MB * 1024 * 1024;
+  private maxFiles: number = DEFAULT_MAX_FILES;
+  private retentionDays: number = DEFAULT_RETENTION_DAYS;
+  private stripAnsiEnabled: boolean = DEFAULT_STRIP_ANSI;
+  private currentLogPath: string = '';
+  private currentLogSizeBytes: number = 0;
+
+  private originalStdoutWrite: typeof process.stdout.write | null = null;
+  private originalStderrWrite: typeof process.stderr.write | null = null;
+
+
+  /**
+   * Telepiti a file logger-t a `DyNTS_global_settings.log_settings.file_log`
+   * config alapjan. Ha `enabled === false` vagy hianyzik a config → no-op.
+   *
+   * Idempotens — masodszori hivas no-op (akkor is, ha kozben a config
+   * valtozott; a service uj install-jara teardownFor Testing() + install()).
+   */
+  install(): void {
+    if (this.installed) { return; }
+
+    const config = DyNTS_global_settings.log_settings?.file_log;
+    if (!config || !config.enabled) { return; }
+
+    // Config feldolgozas + default-ok
+    this.activeLogDir       = config.logDir            ?? DEFAULT_LOG_DIR;
+    this.filenamePrefix     = config.filenamePrefix    ?? DEFAULT_FILENAME_PREFIX;
+    this.maxFileSizeBytes   = (config.maxFileSizeMb    ?? DEFAULT_MAX_FILE_SIZE_MB) * 1024 * 1024;
+    this.maxFiles           = config.maxFiles          ?? DEFAULT_MAX_FILES;
+    this.retentionDays      = config.retentionDays     ?? DEFAULT_RETENTION_DAYS;
+    this.stripAnsiEnabled   = config.stripAnsi         ?? DEFAULT_STRIP_ANSI;
+    const includeStdout: boolean = config.includeStdout ?? DEFAULT_INCLUDE_STDOUT;
+    const includeStderr: boolean = config.includeStderr ?? DEFAULT_INCLUDE_STDERR;
+
+    // Log dir letrehozasa silently
+    try {
+      if (!fs.existsSync(this.activeLogDir)) {
+        fs.mkdirSync(this.activeLogDir, { recursive: true });
+      }
+    } catch {
+      // Ha a mkdir bukik (pl. permission denied), no-op — silent failure
+      return;
+    }
+
+    // Retention cleanup MIELOTT az uj session fajl letrejon (hogy a takaritas
+    // log uzenete ne keruljon a most induló fajlba)
+    this.cleanupOldLogs();
+
+    // Uj session fajl path + size init
+    this.currentLogPath = path.join(this.activeLogDir, this.buildSessionFilename());
+    this.currentLogSizeBytes = 0;
+
+    // Monkey-patch — az originalokat elmentjük (teardown miatt)
+    if (includeStdout) {
+      this.originalStdoutWrite = process.stdout.write.bind(process.stdout);
+      const self: DyNTS_FileLog_Service = this;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      process.stdout.write = function patchedStdoutWrite(...args: any[]): boolean {
+        self.teeWrite(args[0]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (self.originalStdoutWrite as any)(...args);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+    }
+    if (includeStderr) {
+      this.originalStderrWrite = process.stderr.write.bind(process.stderr);
+      const self: DyNTS_FileLog_Service = this;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      process.stderr.write = function patchedStderrWrite(...args: any[]): boolean {
+        self.teeWrite(args[0]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (self.originalStderrWrite as any)(...args);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+    }
+
+    this.installed = true;
+
+    // Session header — kulcs info egy helyen a fajl tetejen
+    this.teeWrite(
+      `===== DyNTS server log session started at ${new Date().toISOString()} =====\n` +
+      `===== PID: ${process.pid}, Node: ${process.version} =====\n` +
+      `===== Retention: ${this.retentionDays} days, max files: ${this.maxFiles}, max size: ${config.maxFileSizeMb ?? DEFAULT_MAX_FILE_SIZE_MB}MB =====\n\n`,
+    );
+  }
+
+  /**
+   * Visszaadja az aktualis log fajl abszolut path-jat (csak akkor letezo,
+   * ha az install() sikeresen lefutott; egyebkent ures string).
+   */
+  getCurrentLogPath(): string {
+    return this.currentLogPath;
+  }
+
+  /**
+   * Telepitve van-e (csak akkor true, ha az enabled === true es a setup nem bukott).
+   */
+  isInstalled(): boolean {
+    return this.installed;
+  }
+
+  /**
+   * Test-only: visszallitja az eredeti stdout/stderr.write-okat, hogy a
+   * specfajlok egymas utan tisztán futhassanak. Production code NE hivja.
+   */
+  _teardownForTesting(): void {
+    if (this.originalStdoutWrite) {
+      process.stdout.write = this.originalStdoutWrite;
+      this.originalStdoutWrite = null;
+    }
+    if (this.originalStderrWrite) {
+      process.stderr.write = this.originalStderrWrite;
+      this.originalStderrWrite = null;
+    }
+    this.installed = false;
+    this.activeLogDir = '';
+    this.currentLogPath = '';
+    this.currentLogSizeBytes = 0;
+  }
+
+
+  /**
+   * Session fajl nev: `{prefix}YYYY-MM-DD_HH-MM-SS_RANDOM.log`. Az RANDOM
+   * suffix biztositja a unique nevet ha ugyanazon a masodpercen tobb fajl jon letre
+   * (pl. rotation kozvetlenul install utan, vagy specfajlok gyors egymas utan).
+   */
+  private buildSessionFilename(): string {
+    const now: Date = new Date();
+    const year: string = String(now.getFullYear());
+    const month: string = String(now.getMonth() + 1).padStart(2, '0');
+    const day: string = String(now.getDate()).padStart(2, '0');
+    const hour: string = String(now.getHours()).padStart(2, '0');
+    const minute: string = String(now.getMinutes()).padStart(2, '0');
+    const second: string = String(now.getSeconds()).padStart(2, '0');
+    const rand: string = Math.floor(Math.random() * 100000).toString(36);
+    return `${this.filenamePrefix}${year}-${month}-${day}_${hour}-${minute}-${second}_${rand}${DEFAULT_FILENAME_SUFFIX}`;
+  }
+
+
+  /**
+   * Egyetlen stdout/stderr iras tee-zese az aktualis log fajlba.
+   * Hibakat csendben elnyeli — a file logger SOHASEM blokkolja a szervert.
+   * Size-trackeli az aktualis fajlt es szukseg szerint rotalja.
+   */
+  private teeWrite(data: string | Uint8Array): void {
+    try {
+      if (!this.currentLogPath) { return; }
+
+      const asString: string = typeof data === 'string'
+        ? data
+        : Buffer.from(data).toString('utf-8');
+      const cleaned: string = this.stripAnsiEnabled ? asString.replace(ANSI_ESCAPE_REGEX, '') : asString;
+      const writeBytes: number = Buffer.byteLength(cleaned, 'utf-8');
+
+      fs.appendFileSync(this.currentLogPath, cleaned, 'utf-8');
+      this.currentLogSizeBytes += writeBytes;
+
+      // Rotation trigger
+      if (this.currentLogSizeBytes >= this.maxFileSizeBytes) {
+        this.rotate();
+      }
+    } catch {
+      // szandekosan elnyelve — silent failure
+    }
+  }
+
+  /**
+   * Uj session fajl letrehozasa (az aktualis lezarodik). Retention cleanup-ot is
+   * vegrehajt, hogy a rotation termeszetesen tisztan tarttsa a log dir-t.
+   */
+  private rotate(): void {
+    try {
+      this.cleanupOldLogs();
+      this.currentLogPath = path.join(this.activeLogDir, this.buildSessionFilename());
+      this.currentLogSizeBytes = 0;
+    } catch {
+      // szandekosan elnyelve
+    }
+  }
+
+
+  /**
+   * Retention takaritas: ket szabaly ami ami elobb teljesul:
+   *   1) maxFiles — ha tobb mint N log fajl van, a legregebbieket torli
+   *   2) retentionDays — `retentionDays`-nel idosebb fajlokat torli
+   *
+   * Hibakat csendben elnyel. A torolt fajlokat es az okot NEM logoljuk, hogy
+   * ne kerüljön extra szennyezes a most induló session fajlba.
+   */
+  private cleanupOldLogs(): void {
+    try {
+      if (!fs.existsSync(this.activeLogDir)) { return; }
+
+      const cutoffMs: number = Date.now() - this.retentionDays * 24 * 60 * 60 * 1000;
+      const entries: string[] = fs.readdirSync(this.activeLogDir);
+
+      type FileInfo = { fullPath: string; mtimeMs: number };
+      const matchingFiles: FileInfo[] = [];
+
+      for (const entry of entries) {
+        if (!entry.startsWith(this.filenamePrefix) || !entry.endsWith(DEFAULT_FILENAME_SUFFIX)) { continue; }
+        const fullPath: string = path.join(this.activeLogDir, entry);
+        try {
+          const stats: fs.Stats = fs.statSync(fullPath);
+          matchingFiles.push({ fullPath: fullPath, mtimeMs: stats.mtimeMs });
+        } catch {
+          // fajlonkent elnyelve
+        }
+      }
+
+      // Sort: legujabb elol -> legregebbi hatul (csokkeno mtime)
+      matchingFiles.sort((a: FileInfo, b: FileInfo): number => b.mtimeMs - a.mtimeMs);
+
+      for (let i: number = 0; i < matchingFiles.length; i++) {
+        const file: FileInfo = matchingFiles[i];
+        const tooOldByAge: boolean = file.mtimeMs < cutoffMs;
+        const tooManyByCount: boolean = i >= this.maxFiles;
+        if (tooOldByAge || tooManyByCount) {
+          try { fs.unlinkSync(file.fullPath); } catch { /* fajlonkent elnyelve */ }
+        }
+      }
+    } catch {
+      // szandekosan elnyelve
+    }
+  }
+}

package/src/_modules/logs/get-logs-routing-module.util.ts

@@ -0,0 +1,36 @@
+import { Request, Response } from 'express';
+
+import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
+
+/**
+ * Letrehoz egy /logs routing module-t a szerver logok lekeresehez.
+ *
+ * Hasznalat (auth NELKUL — barki elerheti):
+ *   DyNTS_getLogsRoutingModule()
+ *
+ * Hasznalat (auth-TAL — a megadott preProcess fut elotte):
+ *   DyNTS_getLogsRoutingModule({
+ *     authPreProcess: authService.authenticate_sercretKey
+ *   })
+ *
+ * FONTOS: A szerver indulasakor meg kell hivni:
+ *   DyNTS_Logs_Service.getInstance().install()
+ * es a log_settings.logs_endpoint.enabled = true kell legyen.
+ */
+export function DyNTS_getLogsRoutingModule(
+  config?: DyNTS_LogsController_Config
+): DyNTS_RoutingModule {
+  // Konfiguracio atadasa a controller-nek (static, mert a singleton elott kell)
+  if (config) {
+    DyNTS_Logs_Controller.configure(config);
+  }
+
+  const set: DyNTS_RoutingModule_Settings = {
+    route: '/logs',
+    controllers: [DyNTS_Logs_Controller.getInstance()],
+  };
+
+  return new DyNTS_RoutingModule(set);
+}

package/src/_modules/logs/index.ts

@@ -0,0 +1,4 @@
+export { DyNTS_Logs_Service } from './logs.service';
+export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
+export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
+export { DyNTS_FileLog_Service } from './file-log.service';

package/src/_modules/logs/log-buffer.service.ts

@@ -0,0 +1,101 @@
+
+import { DyNTS_SingletonService } from '../../_services/base/singleton.service';
+
+/**
+ * In-memory ring buffer a szerver console kimenethez.
+ * Interceptalja a console.log/error/warn/info hivasokat es eltarolja az utolso N sort.
+ *
+ * Hasznalat:
+ *   DyNTS_LogBuffer_Service.getInstance().install();  // app startup-nal
+ *   DyNTS_LogBuffer_Service.getInstance().getLines(100);  // utolso 100 sor
+ */
+export class DyNTS_LogBuffer_Service extends DyNTS_SingletonService {
+
+  static getInstance(): DyNTS_LogBuffer_Service {
+    return DyNTS_LogBuffer_Service.getSingletonInstance();
+  }
+
+  private readonly maxLines: number = 2000;
+  private readonly buffer: string[] = [];
+  private installed: boolean = false;
+
+  /**
+   * Interceptalja a console.log/error/warn/info kimeneteket es a bufferbe irja.
+   * Egyszer kell hivni, a szerver indulasakor (lehetoleg a legelso muvelet).
+   */
+  install(): void {
+    if (this.installed) { return; }
+    this.installed = true;
+
+    const self: DyNTS_LogBuffer_Service = this;
+
+    const originalLog: typeof console.log = console.log.bind(console);
+    const originalError: typeof console.error = console.error.bind(console);
+    const originalWarn: typeof console.warn = console.warn.bind(console);
+    const originalInfo: typeof console.info = console.info.bind(console);
+
+    console.log = (...args: any[]): void => {
+      self.addLine('LOG', args);
+      originalLog(...args);
+    };
+
+    console.error = (...args: any[]): void => {
+      self.addLine('ERR', args);
+      originalError(...args);
+    };
+
+    console.warn = (...args: any[]): void => {
+      self.addLine('WRN', args);
+      originalWarn(...args);
+    };
+
+    console.info = (...args: any[]): void => {
+      self.addLine('INF', args);
+      originalInfo(...args);
+    };
+  }
+
+  /**
+   * A log buffer be van-e kapcsolva (install megtortent-e).
+   */
+  isInstalled(): boolean {
+    return this.installed;
+  }
+
+  /**
+   * Az utolso N sor lekerdezese.
+   */
+  getLines(count: number = 200): string[] {
+    const start: number = Math.max(0, this.buffer.length - count);
+    return this.buffer.slice(start);
+  }
+
+  /**
+   * Az osszes buffered sor szama.
+   */
+  getLineCount(): number {
+    return this.buffer.length;
+  }
+
+  /**
+   * Buffer uritese.
+   */
+  clear(): void {
+    this.buffer.length = 0;
+  }
+
+  private addLine(level: string, args: any[]): void {
+    const timestamp: string = new Date().toISOString();
+    const message: string = args.map(formatArg).join(' ');
+    this.buffer.push(`${timestamp} [${level}] ${message}`);
+
+    if (this.buffer.length > this.maxLines) {
+      this.buffer.shift();
+    }
+  }
+}
+
+function formatArg(arg: any): string {
+  if (typeof arg === 'string') { return arg; }
+  try { return JSON.stringify(arg); } catch { return String(arg); }
+}