@futdevpro/nts-dynamo 1.15.13 → 1.15.15

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