@futdevpro/nts-dynamo 1.15.127 → 1.15.129

package/src/_services/core/request-hunter.service.spec.ts

@@ -0,0 +1,124 @@
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_InFlightRequest, DyNTS_RequestHunter, DyNTS_SlowRequestSample } from './request-hunter.service';
+
+/**
+ * ISSUE-HUNTER — keres-szintu attribucio.
+ *
+ * A mert incidens (overseer 2026-08-05): az event-loop 10-15 mp-re megallt, de SEMMI nem mondta
+ * meg, MELYIK keres okozta. A diagnozis 4893 nyers log-sorbol tortent. Ez a service azt a
+ * kepesseget adja, ami hianyzott: a lassu keres MAGA jelenti magat, nevvel es idovel.
+ */
+describe('| DyNTS_RequestHunter', () => {
+
+  let hunter: DyNTS_RequestHunter;
+
+  beforeEach(() => {
+    hunter = DyNTS_RequestHunter.getInstance();
+    // Tiszta lap: a bennmaradt in-flight bejegyzeseket lezarjuk
+    for (let i = 0; i < 50; i++) { hunter.end(i); }
+    (DyNTS_global_settings as { requestHunter?: unknown }).requestHunter = { enabled: true, slowRequestMs: 20 };
+  });
+
+  afterEach(() => {
+    delete (DyNTS_global_settings as { requestHunter?: unknown }).requestHunter;
+  });
+
+  const wait = (ms: number): Promise<void> =>
+    new Promise<void>((r: () => void): void => { setTimeout(r, ms); });
+
+  describe('| in-flight nyilvantartas', () => {
+
+    it('| a futo keres LATSZIK, a befejezett NEM', () => {
+      // Arrange & Act
+      const id: number = hunter.begin('getCdpReportDetails');
+
+      // Assert — fut
+      const during: DyNTS_InFlightRequest[] = hunter.getInFlight();
+      expect(during.some((r: DyNTS_InFlightRequest): boolean => r.label === 'getCdpReportDetails')).toBeTrue();
+
+      // Act — vege
+      hunter.end(id);
+
+      // Assert — mar nem
+      expect(hunter.getInFlight().some((r: DyNTS_InFlightRequest): boolean => r.label === 'getCdpReportDetails'))
+        .toBeFalse();
+    });
+
+    it('| a leghosszabb ideje futo keres van ELOL (az a gyanus)', async (): Promise<void> => {
+      // Arrange
+      const first: number = hunter.begin('regota-fut');
+      await wait(30);
+      const second: number = hunter.begin('most-indult');
+
+      // Act
+      const list: DyNTS_InFlightRequest[] = hunter.getInFlight();
+
+      // Assert
+      expect(list[0].label).toBe('regota-fut');
+      expect(list[0].ageMs).toBeGreaterThanOrEqual(list[1].ageMs);
+
+      hunter.end(first);
+      hunter.end(second);
+    });
+  });
+
+  describe('| lassu-keres onjelentes (a FO jel)', () => {
+
+    it('| a kuszob folotti keres bekerul a history-ba, nevvel es idovel', async (): Promise<void> => {
+      // Arrange — 20ms a kuszob (beforeEach)
+      const id: number = hunter.begin('getCdpReportDetails');
+      await wait(45);
+
+      // Act
+      hunter.end(id);
+
+      // Assert — EZ az a sor, ami a mai incidenst egy lepesben megadta volna
+      const slow: DyNTS_SlowRequestSample[] = hunter.getSlowHistory();
+      const found: DyNTS_SlowRequestSample | undefined =
+        slow.find((s: DyNTS_SlowRequestSample): boolean => s.label === 'getCdpReportDetails');
+      expect(found).toBeDefined();
+      expect(found!.durationMs).toBeGreaterThanOrEqual(20);
+    });
+
+    it('| a GYORS keres NEM kerul a history-ba (nincs log-flood)', async (): Promise<void> => {
+      // Arrange
+      const before: number = hunter.getSlowHistory().length;
+      const id: number = hunter.begin('gyors-keres');
+
+      // Act
+      hunter.end(id);
+
+      // Assert
+      expect(hunter.getSlowHistory().length).toBe(before);
+    });
+  });
+
+  describe('| robusztussag', () => {
+
+    it('| kikapcsolva a begin 0-t ad, es az end(0) no-op (nem dob)', () => {
+      // Arrange
+      (DyNTS_global_settings as { requestHunter?: unknown }).requestHunter = { enabled: false };
+
+      // Act & Assert
+      const id: number = hunter.begin('barmi');
+      expect(id).toBe(0);
+      expect((): void => hunter.end(0)).not.toThrow();
+    });
+
+    it('| ismeretlen id-re az end no-op (dupla-end / elveszett id sem szivarogtat)', () => {
+      // Act & Assert
+      expect((): void => hunter.end(999999)).not.toThrow();
+    });
+
+    it('| ures in-flight eseten a leiras a SLOW-sorokra iranyit (ez is informacio)', () => {
+      // Arrange — minden lezarva
+      for (let i = 0; i < 50; i++) { hunter.end(i); }
+
+      // Act
+      const text: string = hunter.describeInFlight();
+
+      // Assert — a fagyas ALATT a poll nem fut, ezert az ures lista VARHATO; a szoveg ezt megmondja
+      expect(text).toContain('SLOW');
+    });
+  });
+});

package/src/_services/core/request-hunter.service.ts

@@ -0,0 +1,157 @@
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+/** Egy eppen futo keres a hunter nyilvantartasaban. */
+export interface DyNTS_InFlightRequest {
+  /** Az endpoint neve (`DyNTS_Endpoint_Params.name`). */
+  label: string;
+  /** Mennyi ideje fut (ms). */
+  ageMs: number;
+}
+
+/** Egy mar befejezodott LASSU keres (gorgo history). */
+export interface DyNTS_SlowRequestSample {
+  at: number;
+  label: string;
+  durationMs: number;
+}
+
+/**
+ * ISSUE-HUNTER: **melyik keres blokkolta az event-loopot?**
+ *
+ * ⚠️ MIERT KELLETT (mert incidens, overseer 2026-08-05): az event-loop 10-15 masodpercre
+ * megallt (`DyNTS_EventLoopDiag`: elLag max 10058-14839 ms), a `MemoryGuard` es a healthcheck
+ * ONMAGABAN egyiket sem tudta MIHEZ kotni. A diagnozis igy a nyers log 4893 sorabol tortent,
+ * orak alatt — holott a dontő jel MINDOSSZE 4 sor volt benne. A hianyzo kepesseg nem a MERES
+ * volt (az megvolt), hanem az ATTRIBUCIO: *mi futott, amikor megallt?*
+ *
+ * Ez a service ezt potolja, KET fuggetlen jellel:
+ *
+ *  1. **Lassu-keres onjelentes (a fo jel).** Amikor egy keres BEFEJEZODIK, ha tovabb tartott a
+ *     kuszobnel, azonnal WARN-t ir a nevevel es az idejevel. A mai incidenst EZ egyetlen sorban
+ *     megadta volna: `[REQ-HUNTER] SLOW getCdpReportDetails 10240ms`.
+ *     ⚠️ Miert EZ a fo jel: a fagyas ALATT a diag-poll NEM fut (a loop all), tehat mire lefutna,
+ *     a bunos keres mar befejezodott — az "in-flight pillanatkep" onmagaban ELKESNE.
+ *
+ *  2. **In-flight pillanatkep (a masodik jel).** Azokra az esetekre, amikor a keres MEG MINDIG
+ *     fut (beragadt / vegtelen varakozas): a stall-detektor le tudja kerdezni, mi van eppen
+ *     folyamatban es mennyi ideje.
+ *
+ * KOLTSEG: egy `Map`-beszuras + `Date.now()` keresenkent. Elhanyagolhato; ezert
+ * alapertelmezetten BE van kapcsolva (a mai incidens tanulsaga: ami nincs bekapcsolva, az pont
+ * az incidens alatt nem all rendelkezesre).
+ *
+ * Settings (`DyNTS_global_settings.requestHunter`):
+ *   - `enabled?: boolean`        default true
+ *   - `slowRequestMs?: number`   default 1000 — e felett WARN a keres vegen
+ *   - `maxHistoryCount?: number` default 50 — a lassu-keres history merete
+ */
+export class DyNTS_RequestHunter {
+
+  private static instance: DyNTS_RequestHunter;
+
+  static getInstance(): DyNTS_RequestHunter {
+    if (!DyNTS_RequestHunter.instance) {
+      DyNTS_RequestHunter.instance = new DyNTS_RequestHunter();
+    }
+
+    return DyNTS_RequestHunter.instance;
+  }
+
+  private nextId: number = 1;
+  private readonly inFlight: Map<number, { label: string; startedAt: number }> = new Map();
+  private slowHistory: DyNTS_SlowRequestSample[] = [];
+
+  /** A settings-ertekek feloldasa (minden hivasnal, hogy a runtime-valtoztatas is hasson). */
+  private getSettings(): { enabled: boolean; slowRequestMs: number; maxHistoryCount: number } {
+    const s: { enabled?: boolean; slowRequestMs?: number; maxHistoryCount?: number } =
+      (DyNTS_global_settings as { requestHunter?: Record<string, unknown> }).requestHunter ?? {};
+
+    return {
+      enabled: s.enabled !== false,
+      slowRequestMs: typeof s.slowRequestMs === 'number' && s.slowRequestMs > 0 ? s.slowRequestMs : 1000,
+      maxHistoryCount: typeof s.maxHistoryCount === 'number' && s.maxHistoryCount > 0 ? s.maxHistoryCount : 50,
+    };
+  }
+
+  /**
+   * Keres kezdete. A visszaadott id-t az `end()`-nek kell atadni.
+   *
+   * @returns a keres id-ja, vagy 0 ha a hunter ki van kapcsolva (az `end(0)` no-op)
+   */
+  begin(label: string): number {
+    if (!this.getSettings().enabled) {
+      return 0;
+    }
+
+    const id: number = this.nextId++;
+    this.inFlight.set(id, { label: label, startedAt: Date.now() });
+
+    return id;
+  }
+
+  /**
+   * Keres vege. Ha a kuszobnel tovabb tartott, WARN + bekerul a history-ba.
+   * Hibatur: ismeretlen / 0 id eseten no-op.
+   */
+  end(id: number): void {
+    if (!id) {
+      return;
+    }
+
+    const entry: { label: string; startedAt: number } | undefined = this.inFlight.get(id);
+    if (!entry) {
+      return;
+    }
+    this.inFlight.delete(id);
+
+    const settings: { slowRequestMs: number; maxHistoryCount: number } = this.getSettings();
+    const durationMs: number = Date.now() - entry.startedAt;
+    if (durationMs < settings.slowRequestMs) {
+      return;
+    }
+
+    this.slowHistory.push({ at: Date.now(), label: entry.label, durationMs: durationMs });
+    if (this.slowHistory.length > settings.maxHistoryCount) {
+      this.slowHistory = this.slowHistory.slice(-settings.maxHistoryCount);
+    }
+
+    DyFM_Log.warn(
+      `[REQ-HUNTER] SLOW ${entry.label} ${durationMs}ms`
+      + (this.inFlight.size ? ` (kozben ${this.inFlight.size} masik keres is futott)` : ''),
+    );
+  }
+
+  /** Az EPPEN futo keresek — a stall-detektor ebbol tudja, mi ragadt be. */
+  getInFlight(now: number = Date.now()): DyNTS_InFlightRequest[] {
+    const out: DyNTS_InFlightRequest[] = [];
+    for (const entry of this.inFlight.values()) {
+      out.push({ label: entry.label, ageMs: now - entry.startedAt });
+    }
+
+    return out.sort((a: DyNTS_InFlightRequest, b: DyNTS_InFlightRequest): number => b.ageMs - a.ageMs);
+  }
+
+  /** A kozelmult lassu keresei (gorgo history) — `/server/diag`-ba is kitehető. */
+  getSlowHistory(): DyNTS_SlowRequestSample[] {
+    return [...this.slowHistory];
+  }
+
+  /**
+   * Ember-olvashato in-flight osszefoglalo a stall-loghoz.
+   * Ures listanal expliciten ezt mondja — mert az IS informacio: a blokkolo mar befejezodott,
+   * tehat a lassu-keres onjelentest (1. jel) kell nezni.
+   */
+  describeInFlight(now: number = Date.now()): string {
+    const list: DyNTS_InFlightRequest[] = this.getInFlight(now);
+    if (!list.length) {
+      return 'nincs futo keres (a blokkolo mar befejezodott — lasd a [REQ-HUNTER] SLOW sorokat)';
+    }
+
+    return list
+      .slice(0, 5)
+      .map((r: DyNTS_InFlightRequest): string => `${r.label} (${r.ageMs}ms)`)
+      .join(', ');
+  }
+}

package/src/_services/core/service-collection.service.spec.ts

@@ -1,46 +1,46 @@
-
-import { DyNTS_Service_Collection } from './service-collection.service';
-
-class TestService {
-  name: string;
-  constructor(name: string) {
-    this.name = name;
-  }
-}
-
-describe('| DyNTS_Service_Collection', () => {
-  it('| should be a singleton instance', () => {
-    class TestCollection extends DyNTS_Service_Collection<TestService> {
-      static getInstance(): TestCollection {
-        return TestCollection.getSingletonInstance();
-      }
-    }
-
-    const instance1 = TestCollection.getInstance();
-    const instance2 = TestCollection.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestCollection);
-  });
-
-  it('| should allow dynamic property assignment', () => {
-    class TestCollection extends DyNTS_Service_Collection<TestService> {
-      static getInstance(): TestCollection {
-        return TestCollection.getSingletonInstance();
-      }
-    }
-
-    const collection = TestCollection.getInstance();
-    const service1 = new TestService('service1');
-    const service2 = new TestService('service2');
-
-    collection['service1'] = service1;
-    collection['service2'] = service2;
-
-    expect(collection['service1']).toBe(service1);
-    expect(collection['service2']).toBe(service2);
-    expect(collection['service1'].name).toBe('service1');
-    expect(collection['service2'].name).toBe('service2');
-  });
-});
-
+
+import { DyNTS_Service_Collection } from './service-collection.service';
+
+class TestService {
+  name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+
+describe('| DyNTS_Service_Collection', () => {
+  it('| should be a singleton instance', () => {
+    class TestCollection extends DyNTS_Service_Collection<TestService> {
+      static getInstance(): TestCollection {
+        return TestCollection.getSingletonInstance();
+      }
+    }
+
+    const instance1 = TestCollection.getInstance();
+    const instance2 = TestCollection.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestCollection);
+  });
+
+  it('| should allow dynamic property assignment', () => {
+    class TestCollection extends DyNTS_Service_Collection<TestService> {
+      static getInstance(): TestCollection {
+        return TestCollection.getSingletonInstance();
+      }
+    }
+
+    const collection = TestCollection.getInstance();
+    const service1 = new TestService('service1');
+    const service2 = new TestService('service2');
+
+    collection['service1'] = service1;
+    collection['service2'] = service2;
+
+    expect(collection['service1']).toBe(service1);
+    expect(collection['service2']).toBe(service2);
+    expect(collection['service1'].name).toBe('service1');
+    expect(collection['service2'].name).toBe('service2');
+  });
+});
+

package/src/_services/core/service-collection.service.ts

@@ -1,6 +1,6 @@
-
-import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
-
-export class DyNTS_Service_Collection<T> extends DyNTS_SingletonServiceBase {
-  [service: string]: T;
-}
+
+import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
+
+export class DyNTS_Service_Collection<T> extends DyNTS_SingletonServiceBase {
+  [service: string]: T;
+}

package/src/_services/route/controller.service.spec.ts

@@ -1,53 +1,53 @@
-
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
-import { DyNTS_Controller } from './controller.service';
-
-class TestController extends DyNTS_Controller {
-  setupEndpoints(): void {
-    this.endpoints = [
-      new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test-endpoint',
-        preProcesses: [],
-        tasks: [
-          async (req: any, res: any) => {
-            res.send({ message: 'Test successful' });
-          },
-        ],
-      }),
-    ];
-  }
-
-  static getInstance(): TestController {
-    return new TestController();
-  }
-}
-
-describe('| DyNTS_Controller', () => {
-  let controller: TestController;
-
-  beforeEach(() => {
-    controller = TestController.getInstance();
-    controller.setupEndpoints();
-  });
-
-  it('| should initialize endpoints correctly', () => {
-    expect(controller.endpoints.length).toBe(1);
-    expect(controller.endpoints[0].name).toBe('testEndpoint');
-    expect(controller.endpoints[0].endpoint).toBe('/test-endpoint');
-  });
-
-  /* it('| should execute task and send response', async () => {
-    const req = {};
-    const res = {
-      send: jasmine.createSpy('send'),
-    };
-
-    await controller.endpoints[0].tasks[0](req, res);
-
-    expect(res.send).toHaveBeenCalledWith({ message: 'Test successful' });
-  }); */
-});
+
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Controller } from './controller.service';
+
+class TestController extends DyNTS_Controller {
+  setupEndpoints(): void {
+    this.endpoints = [
+      new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test-endpoint',
+        preProcesses: [],
+        tasks: [
+          async (req: any, res: any) => {
+            res.send({ message: 'Test successful' });
+          },
+        ],
+      }),
+    ];
+  }
+
+  static getInstance(): TestController {
+    return new TestController();
+  }
+}
+
+describe('| DyNTS_Controller', () => {
+  let controller: TestController;
+
+  beforeEach(() => {
+    controller = TestController.getInstance();
+    controller.setupEndpoints();
+  });
+
+  it('| should initialize endpoints correctly', () => {
+    expect(controller.endpoints.length).toBe(1);
+    expect(controller.endpoints[0].name).toBe('testEndpoint');
+    expect(controller.endpoints[0].endpoint).toBe('/test-endpoint');
+  });
+
+  /* it('| should execute task and send response', async () => {
+    const req = {};
+    const res = {
+      send: jasmine.createSpy('send'),
+    };
+
+    await controller.endpoints[0].tasks[0](req, res);
+
+    expect(res.send).toHaveBeenCalledWith({ message: 'Test successful' });
+  }); */
+});