@futdevpro/nts-dynamo 1.15.17 → 1.15.19

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); }
+}

package/src/_modules/logs/logs.controller.ts

@@ -0,0 +1,109 @@
+import { Request, Response } from 'express';
+
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_Logs_Service } from './logs.service';
+
+/**
+ * Overseer-szintu log parameter tipus.
+ * Az authPreProcess opcionalis — ha megadod, a /get endpoint vedett lesz.
+ */
+export interface DyNTS_LogsController_Config {
+  /** Opcionalis auth preprocess. Ha nincs megadva → nyilt hozzaferes. */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+}
+
+/**
+ * NTS Logs Controller — beepitett /logs/get endpoint a szerver logok lekeresehez.
+ *
+ * Hasznalat:
+ *   DyNTS_getLogsRoutingModule()  — auth nelkul
+ *   DyNTS_getLogsRoutingModule({ authPreProcess: myAuth })  — auth-tal
+ *
+ * Ha a logs_endpoint.enabled === false, a controller 503-at dob.
+ */
+export class DyNTS_Logs_Controller extends DyNTS_Controller {
+
+  private static config: DyNTS_LogsController_Config = {};
+
+  static configure(config: DyNTS_LogsController_Config): void {
+    DyNTS_Logs_Controller.config = config;
+  }
+
+  static getInstance(): DyNTS_Logs_Controller {
+    return DyNTS_Logs_Controller.getSingletonInstance();
+  }
+
+  private readonly logsService: DyNTS_Logs_Service = DyNTS_Logs_Service.getInstance();
+
+  setupEndpoints(): void {
+    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
+    if (DyNTS_Logs_Controller.config.authPreProcess) {
+      preProcesses.push(DyNTS_Logs_Controller.config.authPreProcess);
+    }
+
+    this.endpoints = [
+      // GET /get?tail=200 — utolso N sor a log bufferbol
+      new DyNTS_Endpoint_Params({
+        name: 'getLogs',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/get',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            // Ellenorzes: be van-e kapcsolva a logs endpoint
+            if (!DyNTS_global_settings.log_settings?.logs_endpoint?.enabled) {
+              res.status(503).send({
+                error: 'Logs endpoint is not enabled on this server.',
+                hint: 'Set DyNTS_global_settings.log_settings.logs_endpoint.enabled = true',
+              });
+              return;
+            }
+
+            // Ellenorzes: install megtortent-e
+            if (!this.logsService.isInstalled()) {
+              res.status(503).send({
+                error: 'Log buffer is not installed. Call DyNTS_Logs_Service.getInstance().install() at server startup.',
+              });
+              return;
+            }
+
+            const tail: number = Math.min(parseInt(req.query.tail as string) || 200, 2000);
+            const lines: string[] = this.logsService.getLines(tail);
+
+            res.send({
+              totalBuffered: this.logsService.getLineCount(),
+              returned: lines.length,
+              lines: lines,
+            });
+          },
+        ],
+      }),
+
+      // DELETE /clear — buffer uritese
+      new DyNTS_Endpoint_Params({
+        name: 'clearLogs',
+        type: DyFM_HttpCallType.delete,
+        endpoint: '/clear',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            if (!DyNTS_global_settings.log_settings?.logs_endpoint?.enabled) {
+              res.status(503).send({ error: 'Logs endpoint is not enabled.' });
+              return;
+            }
+
+            const count: number = this.logsService.getLineCount();
+            this.logsService.clear();
+            res.send({ result: 'Log buffer cleared', clearedLines: count });
+          },
+        ],
+      }),
+    ];
+  }
+}

package/src/_modules/logs/logs.service.ts

@@ -0,0 +1,100 @@
+import { DyNTS_SingletonServiceBase } from '../../_services/base/singleton.service-base';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+/**
+ * In-memory ring buffer a szerver logokhoz.
+ * Interceptalja a console.log/error/warn kimeneteket es tarolja oket.
+ * Max entryszam a log_settings.logs_endpoint.maxEntries-bol jon (default: 2000).
+ *
+ * Hasznalat:
+ *   DyNTS_Logs_Service.getInstance().install()  — egyszer, szerver indulasakor
+ *   DyNTS_Logs_Service.getInstance().getLines(200)  — utolso N sor
+ */
+export class DyNTS_Logs_Service extends DyNTS_SingletonServiceBase {
+
+  static getInstance(): DyNTS_Logs_Service {
+    return DyNTS_Logs_Service.getSingletonInstance() as DyNTS_Logs_Service;
+  }
+
+  private readonly maxEntries: number;
+  private readonly buffer: string[] = [];
+  private installed: boolean = false;
+
+  protected constructor() {
+    super();
+    this.maxEntries = DyNTS_global_settings.log_settings?.logs_endpoint?.maxEntries ?? 2000;
+  }
+
+  /**
+   * Interceptalja a console.log/error/warn kimeneteket es a bufferbe irja.
+   * Egyszer kell hivni, a szerver indulasakor. Tobbszori hivas no-op.
+   */
+  install(): void {
+    if (this.installed) { return; }
+    this.installed = true;
+
+    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 self: DyNTS_Logs_Service = this;
+
+    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);
+    };
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * Osszes bufferelt sor szama.
+   */
+  getLineCount(): number {
+    return this.buffer.length;
+  }
+
+  /**
+   * Buffer uritese.
+   */
+  clear(): void {
+    this.buffer.length = 0;
+  }
+
+  /**
+   * Telepitve van-e mar a console intercept.
+   */
+  isInstalled(): boolean {
+    return this.installed;
+  }
+
+  private addLine(level: string, args: any[]): void {
+    const message: string = args.map((arg: any) => {
+      if (typeof arg === 'string') { return arg; }
+      try { return JSON.stringify(arg); } catch { return String(arg); }
+    }).join(' ');
+
+    const timestamped: string = `${new Date().toISOString()} [${level}] ${message}`;
+    this.buffer.push(timestamped);
+
+    if (this.buffer.length > this.maxEntries) {
+      this.buffer.shift();
+    }
+  }
+}