@futdevpro/nts-dynamo 1.15.144 → 1.15.150

package/src/_modules/server/server-status/server-status.control-service.ts

@@ -1,491 +1,491 @@
-
-
-import { 
-  DyFM_Metadata, DyFM_RelativeDate, DyFM_Time, DyFM_ServerStatus, DyFM_ErrorLevel, DyFM_Log, 
-  DyFM_Error, DyFM_Error_Statistics, DyFM_Errors, 
-  DyFM_Paged,
-  hour, minute,
-  DyFM_ServerConnectionCheckResult,
-  DyFM_ServerConnection_Status,
-  DyFM_Array
-} from '@futdevpro/fsm-dynamo';
-import { Subscription, timer } from 'rxjs';
-import * as mongoose from 'mongoose';
-
-import { version as _serverVersion } from '../../../../package.json';
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
-import { DyNTS_DbStats, DyNTS_DbStats_Util } from '../../../_services/core/db-stats.service';
-import { DyNTS_Diagnostics, DyNTS_DoctorReport } from '../../../_services/core/diagnostics.service';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
-import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import { DyNTS_ApiService_Base } from '../../../_services/base/api.service-base';
-
-export interface DyNTS_ServerConnection {
-  name: string,
-  apiService: DyNTS_ApiService_Base,
-  accessible?: boolean,
-  lastCheck?: Date,
-}
-
-/**
- * A readiness-probe ({@link DyNTS_ServerStatus_ControlService.checkDbReadiness}) eredménye.
- * `ready=true` CSAK ha a DB-connection él (readyState=1) ÉS a valós ping round-trip sikerült.
- */
-export interface DyNTS_DbReadiness {
-  /** ready: a DB elérhető (readyState=1 + sikeres ping). Erre adjon az endpoint 200-at, különben 503-at. */
-  ready: boolean;
-  /** mongoose connection.readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting. */
-  dbReadyState: number;
-  /** Sikerült-e a valós DB ping round-trip (csak readyState=1-nél próbáljuk). */
-  dbPingOk: boolean;
-  /** A szerver uptime ms-ban. */
-  uptime: number;
-  /** A BEDROCK (nts-dynamo) verziója — NEM az app sajátja. */
-  serverVersion: string;
-  /** AZ APP saját verziója (`DyNTS_global_settings.systemVersion`) — deploy-verifikációhoz. */
-  appVersion?: string;
-
-  // --- DIAGNOSZTIKA (2026-07-22) — a flotta-szintű "readiness 503, de az app kiszolgál" lelet miatt ---
-  // Élesben mérve: az adventor / token-service / master-prompter MIND `dbReadyState:0`-t adott, miközben
-  // kiszolgáltak, a Mongo bizonyítottan élt, és a reconnect-guard (amely UGYANEZT a readyState-et olvassa)
-  // egyetlen warningot sem logolt. Öt hipotézist zártunk ki méréssel (több replika · két mongoose-példány ·
-  // esModule default-export · leszármazott-override · halott DB) — a gyökér-ok NEM dőlt el. Ezek a mezők
-  // teszik a KÖVETKEZŐ mérést döntővé, találgatás nélkül. Mind ADDITÍV + opcionális → nem törnek meg semmit.
-
-  /** Hány mongoose-connection létezik ebben a process-ben (`mongoose.connections.length`). >1 → nem a default-on megy a data-layer. */
-  dbConnectionCount?: number;
-  /** A default connection cél-hosztja (`connection.host`) — üres/undefined, ha a connect sosem futott le rajta. */
-  dbHost?: string;
-  /** A default connection adatbázis-neve (`connection.name`). */
-  dbName?: string;
-  /** Hány model van a default connectionre regisztrálva. 0 → a data-layer NEM ezt a connectiont használja. */
-  dbModelCount?: number;
-  /** A NEM-default connectionök readyState-jei — ha itt van 1-es, a probe rossz handle-t mér. */
-  dbOtherReadyStates?: number[];
-}
-
-export abstract class DyNTS_ServerStatus_ControlService<
-  T_ServerStatus extends DyFM_ServerStatus,
-  T_Error extends DyFM_Error,
-  T_Errors extends DyFM_Errors<T_Error>,
-  T_Errors_ControlService extends DyNTS_Errors_ControlService<T_Error, T_Errors>,
-  T_ServerStatusSnapshot extends DyFM_ServerStatus,
-  T_ServerStatusSnapshot_ControlService extends DyNTS_ServerStatusSnapshot_ControlService<T_ServerStatusSnapshot>
-> extends DyNTS_SingletonService {
-
-  protected abstract getErrorControlService?(
-    set?: { data?: T_Errors, issuer?: string }
-  ): T_Errors_ControlService;
-
-  protected abstract getServerStatusSnapshotControlService?(
-    set?: { data?: T_ServerStatus, issuer?: string }
-  ): T_ServerStatusSnapshot_ControlService;
-
-  protected readonly up: Date = new Date();
-
-  protected readonly _serverVersionNumeric: number = this.getVersionNumeric(_serverVersion);
-  /**
-   * A BEDROCK (nts-dynamo) verzioja — a package.json-bol importalva.
-   * FIGYELEM: ez NEM az app sajat verzioja! (Lasd `appVersion`.)
-   */
-  get serverVersion(): string { return _serverVersion; }
-  get serverVersionNumeric(): number { return this._serverVersionNumeric; }
-
-  /**
-   * AZ APP sajat verzioja (2026-07-20) — a `DyNTS_App_Params.version`-bol, amit az
-   * app-params a `DyNTS_global_settings.systemVersion`-be tolt (app-params.control-model).
-   *
-   * MIERT KELLETT: a `serverVersion` az nts-dynamo package.json-jabol jon, ezert a TELJES
-   * flottan UGYANAZT az erteket adja (pl. 01.15.104), fuggetlenul attol, hogy az app melyik
-   * verzioja fut. Emiatt minden verzio-alapu deploy-ellenorzes vak volt:
-   *   - a CI/CD `deploy-verify` polling SOHA nem egyezne (app 01.15.142 vs serverVersion 01.15.104),
-   *   - az Overseer verzio-drift monitorozasa nem latja az ELAVULT app-deployt,
-   *   - a `fdp deploy-service --skip-if-version` gate mindig eltérést lát → sosem skippel.
-   *
-   * ADDITIV mezo: a `serverVersion` szemantikaja VALTOZATLAN marad (nulla regresszio a
-   * meglevo fogyasztoknal / e2e-knel); az uj fogyasztok az `appVersion`-t olvassak.
-   */
-  get appVersion(): string { return DyNTS_global_settings.systemVersion; }
-
-  protected _latestClientVersion: string;
-  protected _latestClientVersionNumeric: number;
-  get latestClientVersion(): string { return this._latestClientVersion; }
-  get latestClientVersionNumeric(): number { return this._latestClientVersionNumeric; }
-
-  protected abstract requiredServerConnections: DyNTS_ServerConnection[];
-  protected connectionMaxCheckFrequency = 15 * minute;
-
-  override readonly defaultErrorUserMsg = 'Something went wrong';  
-
-  readonly overseerTickTime = 6 * hour;
-  overseer: Subscription;
-
-  protected constructor() {
-    super();
-
-    /* if (DyNTS_global_settings.log_settings.setup) {
-      DyFM_Log.log(
-        'Required server connections:', JSON.stringify(this.requiredServerConnections.map(
-          (connection: DyNTS_ServerConnection): { name: string, baseUrl: string, testEndpoint: string } => ({
-            name: connection.name,
-            baseUrl: connection.apiService.baseUrl,
-            testEndpoint: connection.apiService.testEndpoint ?? '',
-          })
-        ), null, 2)
-      );
-    } */
-
-    this.overseer = timer(this.overseerTickTime, this.overseerTickTime).subscribe(async () => {
-      try {
-        await this.triggerCreateSnapshot('overseer-system-tick');
-      } catch (error) {
-        DyFM_Error.logSimple(' ! Error in overseer (server status):', error);
-        DyNTS_GlobalService.globalErrorHandler(
-          new DyFM_Error({
-            ...this.getDefaultErrorSettings('overseer tick', error, 'overseer-system-tick'),
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-OT0`,
-          })
-        ).catch();
-      }
-    });
-  }
-
-  async getServerStatus(issuer: string, clientVersion?: string): Promise<DyFM_ServerStatus> {
-    try {
-      return {
-        status: 'ready',
-
-        systemName: DyNTS_global_settings.systemName,
-        systemShortCode: DyNTS_global_settings.systemShortCodeName,
-
-        clientVersionOk: clientVersion ? this.clientVersionIsLatest(clientVersion) : false,
-        latestClientVersion: this.latestClientVersion,
-        latestClientVersionNumeric: this.latestClientVersionNumeric,
-
-        serverVersion: this.serverVersion,
-        serverNumericVersion: this.serverVersionNumeric,
-        // Az APP sajat verzioja (a serverVersion a bedrock-e) — deploy-verifikaciohoz.
-        appVersion: this.appVersion,
-
-        uptime: +new Date() - +this.up,
-
-        memoryUsage: process.memoryUsage(),
-        cpuUsage: process.cpuUsage(),
-        serverConnections: await this.checkServerConnections(issuer),
-      } 
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('getServerStatus', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-GSS0`,
-      });
-    }
-  }
-
-  async checkServerConnections(issuer: string): Promise<DyFM_ServerConnectionCheckResult> {
-    try {
-      const connections: DyFM_ServerConnectionCheckResult = {};
-
-      await DyFM_Array.asyncForEachAllAtOnce(
-        this.requiredServerConnections,
-        async (connection: DyNTS_ServerConnection) => {
-          if (!connection.accessible || Date.now() - connection.lastCheck.getTime() > this.connectionMaxCheckFrequency) {
-            await connection.apiService.checkServerAvailability(issuer).catch((error) => {
-              DyFM_Error.logSimple(
-                `(checkServerConnections) "${connection.name}" server is not available` +
-                `\n    baseUrl: ${connection.apiService.baseUrl}` +
-                `\n    testEndpoint: ${connection.apiService.testEndpoint ?? ''}`, 
-                error
-              );
-              connection.accessible = false;
-            }).then(() => {
-              connection.accessible = true;
-            });
-            connection.accessible = true;
-            connection.lastCheck = new Date();
-          }
-
-          connections[connection.name] = connection.accessible ? DyFM_ServerConnection_Status.accessible : DyFM_ServerConnection_Status.unaccessible;
-        }
-      )
-
-      return connections;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('checkServerConnections', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-CC0`,
-      });
-    }
-  }
-
-  /**
-   * A mongoose default-connection. Külön metódus = teszt-seam (spy-jal felülírható, hogy a
-   * {@link checkDbReadiness} DB nélkül is tesztelhető legyen).
-   */
-  /** BFR-OVERSEER-004 — stats-only DB-diagnosztika a `/server/db-stats` endpointnak (metaadat-only). */
-  async getDbStats(): Promise<DyNTS_DbStats> {
-    return DyNTS_DbStats_Util.collect(this.getMongooseConnection());
-  }
-
-  /** BFR-AM-015 — aggregált doctor-riport a `/server/doctor` endpointnak (sosem dob). */
-  async runDoctor(): Promise<DyNTS_DoctorReport> {
-    return DyNTS_Diagnostics.runDoctor({ connection: this.getMongooseConnection() });
-  }
-
-  protected getMongooseConnection(): mongoose.Connection {
-    // FIX (2026-07-22) — a `mongoose.connection` NEM feltetlenul az a handle, amit a data-layer hasznal.
-    //
-    // ELESBEN MERVE (adventor, a diagnosztikai mezokkel): `dbConnectionCount: 1`, `dbModelCount: 0`,
-    // `dbOtherReadyStates: [1]` — azaz letezik EGY KAPCSOLODOTT (readyState=1) connection, de a
-    // `mongoose.connection` **nem az**: az disconnected (0), NULLA modellel, `host`/`name` nelkul
-    // (sosem csatlakozott). Emiatt a readiness flotta-szinten **hamis 503**-at adott (adventor,
-    // token-service, master-prompter), mikozben a DB vegig egeszseges volt es az appok kiszolgaltak.
-    //
-    // Ezert a valos, KAPCSOLODOTT connectiont keressuk meg a `mongoose.connections`-bol, es csak
-    // fallbackkent hasznaljuk a `mongoose.connection`-t. Ez minden esetben helyes:
-    //  - ha van elo connection -> azt merjuk (readyState=1 + valos ping) -> a readiness igazat mond,
-    //  - ha a DB tenyleg halott -> egyik sem 1 -> fallback -> tovabbra is helyesen NEM-ready.
-    // Vagyis a valodi DB-kiesest NEM maszkolja el, csak a hamis-negativot szunteti meg.
-    const all: mongoose.Connection[] = mongoose.connections ?? [];
-    const live: mongoose.Connection | undefined =
-      all.find((c: mongoose.Connection): boolean => c?.readyState === 1);
-
-    return live ?? mongoose.connection;
-  }
-
-  /**
-   * Readiness-probe: a `/health` (liveness — "a process fut + kiszolgál") MELLETT a DB-elérhetőséget
-   * ellenőrzi. A readyState (mongoose driver-állapot) + egy valós `ping` round-trip → így a "connected
-   * de a DB nem válaszol" eset is kibukik. **Sosem dob** (a probe-nak determinisztikusan kell válaszolnia);
-   * hiba esetén `ready=false`. Az endpoint 503-at adjon, ha nem ready → az orchestrátor (k8s/docker/LB)
-   * ne irányítson forgalmat a DB-vesztett instance-ra.
-   */
-  async checkDbReadiness(): Promise<DyNTS_DbReadiness> {
-    let dbReadyState: number = 0;
-    let dbPingOk: boolean = false;
-
-    try {
-      const connection: mongoose.Connection = this.getMongooseConnection();
-      // readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting
-      dbReadyState = connection?.readyState ?? 0;
-
-      if (dbReadyState === 1) {
-        await connection.db?.admin().ping();
-        dbPingOk = true;
-      }
-    } catch (error) {
-      DyFM_Log.warn('(checkDbReadiness) DB readiness check failed', error);
-      dbPingOk = false;
-    }
-
-    // DIAGNOSZTIKA (2026-07-22): sosem dobhat — a probe-nak determinisztikusan kell válaszolnia,
-    // ezért a diag-gyűjtés SAJÁT try-ban van (ha bármelyik mező kiolvasása elszáll, a readiness
-    // válasz attól még ép marad).
-    let diagnostics: Partial<DyNTS_DbReadiness> = {};
-    try {
-      const conn: mongoose.Connection = this.getMongooseConnection();
-      const all: mongoose.Connection[] = mongoose.connections ?? [];
-
-      diagnostics = {
-        dbConnectionCount: all.length,
-        dbHost: conn?.host,
-        dbName: conn?.name,
-        dbModelCount: Object.keys(conn?.models ?? {}).length,
-        // a default connectiont kihagyjuk — csak a "van-e MÁSIK, élő handle" kérdés érdekes
-        dbOtherReadyStates: all.filter((c: mongoose.Connection): boolean => c !== conn)
-          .map((c: mongoose.Connection): number => c?.readyState ?? -1),
-      };
-    } catch (error) {
-      DyFM_Log.warn('(checkDbReadiness) diagnostics collection failed (non-fatal)', error);
-    }
-
-    return {
-      ready: dbReadyState === 1 && dbPingOk,
-      dbReadyState: dbReadyState,
-      dbPingOk: dbPingOk,
-      uptime: +new Date() - +this.up,
-      serverVersion: this.serverVersion,
-      appVersion: this.appVersion,
-      ...diagnostics,
-    };
-  }
-
-  async getErrorStatistics(
-    range: DyFM_RelativeDate,
-    issuer: string
-  ): Promise<DyFM_Error_Statistics> {
-    try {
-      const error_DS: T_Errors_ControlService = 
-        this.getErrorControlService({ issuer: issuer });
-        /* new DyNTS_Error_DataService({ issuer: issuer }); */
-
-      const from: Date = DyFM_Time.getDateByRelativeDate(range);
-      const errorsPaged: DyFM_Paged<T_Errors> = await error_DS.getErrorsFromDate(from, issuer);
-      const errors: T_Errors[] = errorsPaged.items;
-
-      return {
-        range: range,
-
-        allErrors: errors.length,
-        allAllErrors: errors.reduce(
-          (sum: number, error: T_Errors): number => sum + error.count, 
-          0
-        ),
-
-        serverErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.source.includes('SERVER')
-          ).length,
-        clientErrors:
-          errors.filter(
-            (error: T_Errors): boolean => !error.source.includes('SERVER')
-          ).length,
-        allServerErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.source.includes('SERVER')
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-        allClientErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => !error.source.includes('SERVER')
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-
-        infoErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
-          ).length,
-        warningErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
-          ).length,
-        errorErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
-          ).length,
-        criticalErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
-          ).length,
-
-        allInfoErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-        allWarningErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-        allErrorErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-        allCriticalErrors: 
-          errors.filter(
-            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
-          ).reduce(
-            (sum: number, error: T_Errors): number => sum + error.count, 0
-          ),
-      } as DyFM_Error_Statistics;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'getMatchStatistics',
-          error?.response?.data ?? error,
-          issuer
-        ),
-
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSS-GES0`,
-      });
-    }
-  }
-
-  protected getVersionNumeric(version: string): number {
-    return +version.replace('v', '')
-      .replace('.', '')
-      .replace('.', '')
-      .replace('-alpha', '')
-      .replace('-beta', '')
-      .replace('-test', '')
-      .replace('-dev', '');
-  }
-
-  protected clientVersionIsLatest(clientVersion: string): boolean {
-    const thisClientVersionNumeric: number = this.getVersionNumeric(clientVersion);
-
-    if (!this._latestClientVersionNumeric) {
-      this.setLatestClientVersion(clientVersion, thisClientVersionNumeric);
-
-      return true;
-
-    } else if (thisClientVersionNumeric === this._latestClientVersionNumeric) {
-      return true;
-
-    } else if (thisClientVersionNumeric < this._latestClientVersionNumeric) {
-      return false;
-
-    } else if (this._latestClientVersionNumeric < thisClientVersionNumeric) {
-      this.setLatestClientVersion(clientVersion, thisClientVersionNumeric);
-
-      return true;
-    }
-
-    DyFM_Log.error(
-      'Something went wrong, invalid version:', clientVersion,
-      thisClientVersionNumeric, _serverVersion, this.serverVersionNumeric
-    );
-
-    return false;
-  }
-
-  protected setLatestClientVersion(clientVersion: string, clientVersionNumeric: number): void {
-    if (!clientVersion.includes('test') && !clientVersion.includes('dev')) {
-      this._latestClientVersion = clientVersion;
-      this._latestClientVersionNumeric = clientVersionNumeric;
-    }
-  }
-
-  protected async triggerCreateSnapshot(issuer: string): Promise<void> {
-    try {
-      const snapshot: T_ServerStatusSnapshot = await this.getServerStatusSnapshot(issuer);
-      const serverStatusSnapshot_CS: T_ServerStatusSnapshot_ControlService = 
-        this.getServerStatusSnapshotControlService({ issuer: issuer });
-
-      await serverStatusSnapshot_CS.saveSnapshot(snapshot, issuer);
-
-      DyFM_Log.info('ServerStatus snapshot created');
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('triggerCreateSnapshot', error, 'system-tick'),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-TCS0`,
-      });
-    }
-  }
-
-  async getServerStatusSnapshot(issuer: string): Promise<T_ServerStatusSnapshot> {
-    try {
-      return ({
-        ...(await this.getServerStatus(issuer)),
-      }) as T_ServerStatusSnapshot;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'getServerStatusSnapshot',
-          error?.response?.data ?? error,
-          issuer
-        ),
-
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-GSS0`,
-      });
-    }
-  }
+
+
+import { 
+  DyFM_Metadata, DyFM_RelativeDate, DyFM_Time, DyFM_ServerStatus, DyFM_ErrorLevel, DyFM_Log, 
+  DyFM_Error, DyFM_Error_Statistics, DyFM_Errors, 
+  DyFM_Paged,
+  hour, minute,
+  DyFM_ServerConnectionCheckResult,
+  DyFM_ServerConnection_Status,
+  DyFM_Array
+} from '@futdevpro/fsm-dynamo';
+import { Subscription, timer } from 'rxjs';
+import * as mongoose from 'mongoose';
+
+import { version as _serverVersion } from '../../../../package.json';
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_DbStats, DyNTS_DbStats_Util } from '../../../_services/core/db-stats.service';
+import { DyNTS_Diagnostics, DyNTS_DoctorReport } from '../../../_services/core/diagnostics.service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
+import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+import { DyNTS_ApiService_Base } from '../../../_services/base/api.service-base';
+
+export interface DyNTS_ServerConnection {
+  name: string,
+  apiService: DyNTS_ApiService_Base,
+  accessible?: boolean,
+  lastCheck?: Date,
+}
+
+/**
+ * A readiness-probe ({@link DyNTS_ServerStatus_ControlService.checkDbReadiness}) eredménye.
+ * `ready=true` CSAK ha a DB-connection él (readyState=1) ÉS a valós ping round-trip sikerült.
+ */
+export interface DyNTS_DbReadiness {
+  /** ready: a DB elérhető (readyState=1 + sikeres ping). Erre adjon az endpoint 200-at, különben 503-at. */
+  ready: boolean;
+  /** mongoose connection.readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting. */
+  dbReadyState: number;
+  /** Sikerült-e a valós DB ping round-trip (csak readyState=1-nél próbáljuk). */
+  dbPingOk: boolean;
+  /** A szerver uptime ms-ban. */
+  uptime: number;
+  /** A BEDROCK (nts-dynamo) verziója — NEM az app sajátja. */
+  serverVersion: string;
+  /** AZ APP saját verziója (`DyNTS_global_settings.systemVersion`) — deploy-verifikációhoz. */
+  appVersion?: string;
+
+  // --- DIAGNOSZTIKA (2026-07-22) — a flotta-szintű "readiness 503, de az app kiszolgál" lelet miatt ---
+  // Élesben mérve: az adventor / token-service / master-prompter MIND `dbReadyState:0`-t adott, miközben
+  // kiszolgáltak, a Mongo bizonyítottan élt, és a reconnect-guard (amely UGYANEZT a readyState-et olvassa)
+  // egyetlen warningot sem logolt. Öt hipotézist zártunk ki méréssel (több replika · két mongoose-példány ·
+  // esModule default-export · leszármazott-override · halott DB) — a gyökér-ok NEM dőlt el. Ezek a mezők
+  // teszik a KÖVETKEZŐ mérést döntővé, találgatás nélkül. Mind ADDITÍV + opcionális → nem törnek meg semmit.
+
+  /** Hány mongoose-connection létezik ebben a process-ben (`mongoose.connections.length`). >1 → nem a default-on megy a data-layer. */
+  dbConnectionCount?: number;
+  /** A default connection cél-hosztja (`connection.host`) — üres/undefined, ha a connect sosem futott le rajta. */
+  dbHost?: string;
+  /** A default connection adatbázis-neve (`connection.name`). */
+  dbName?: string;
+  /** Hány model van a default connectionre regisztrálva. 0 → a data-layer NEM ezt a connectiont használja. */
+  dbModelCount?: number;
+  /** A NEM-default connectionök readyState-jei — ha itt van 1-es, a probe rossz handle-t mér. */
+  dbOtherReadyStates?: number[];
+}
+
+export abstract class DyNTS_ServerStatus_ControlService<
+  T_ServerStatus extends DyFM_ServerStatus,
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>,
+  T_Errors_ControlService extends DyNTS_Errors_ControlService<T_Error, T_Errors>,
+  T_ServerStatusSnapshot extends DyFM_ServerStatus,
+  T_ServerStatusSnapshot_ControlService extends DyNTS_ServerStatusSnapshot_ControlService<T_ServerStatusSnapshot>
+> extends DyNTS_SingletonService {
+
+  protected abstract getErrorControlService?(
+    set?: { data?: T_Errors, issuer?: string }
+  ): T_Errors_ControlService;
+
+  protected abstract getServerStatusSnapshotControlService?(
+    set?: { data?: T_ServerStatus, issuer?: string }
+  ): T_ServerStatusSnapshot_ControlService;
+
+  protected readonly up: Date = new Date();
+
+  protected readonly _serverVersionNumeric: number = this.getVersionNumeric(_serverVersion);
+  /**
+   * A BEDROCK (nts-dynamo) verzioja — a package.json-bol importalva.
+   * FIGYELEM: ez NEM az app sajat verzioja! (Lasd `appVersion`.)
+   */
+  get serverVersion(): string { return _serverVersion; }
+  get serverVersionNumeric(): number { return this._serverVersionNumeric; }
+
+  /**
+   * AZ APP sajat verzioja (2026-07-20) — a `DyNTS_App_Params.version`-bol, amit az
+   * app-params a `DyNTS_global_settings.systemVersion`-be tolt (app-params.control-model).
+   *
+   * MIERT KELLETT: a `serverVersion` az nts-dynamo package.json-jabol jon, ezert a TELJES
+   * flottan UGYANAZT az erteket adja (pl. 01.15.104), fuggetlenul attol, hogy az app melyik
+   * verzioja fut. Emiatt minden verzio-alapu deploy-ellenorzes vak volt:
+   *   - a CI/CD `deploy-verify` polling SOHA nem egyezne (app 01.15.142 vs serverVersion 01.15.104),
+   *   - az Overseer verzio-drift monitorozasa nem latja az ELAVULT app-deployt,
+   *   - a `fdp deploy-service --skip-if-version` gate mindig eltérést lát → sosem skippel.
+   *
+   * ADDITIV mezo: a `serverVersion` szemantikaja VALTOZATLAN marad (nulla regresszio a
+   * meglevo fogyasztoknal / e2e-knel); az uj fogyasztok az `appVersion`-t olvassak.
+   */
+  get appVersion(): string { return DyNTS_global_settings.systemVersion; }
+
+  protected _latestClientVersion: string;
+  protected _latestClientVersionNumeric: number;
+  get latestClientVersion(): string { return this._latestClientVersion; }
+  get latestClientVersionNumeric(): number { return this._latestClientVersionNumeric; }
+
+  protected abstract requiredServerConnections: DyNTS_ServerConnection[];
+  protected connectionMaxCheckFrequency = 15 * minute;
+
+  override readonly defaultErrorUserMsg = 'Something went wrong';  
+
+  readonly overseerTickTime = 6 * hour;
+  overseer: Subscription;
+
+  protected constructor() {
+    super();
+
+    /* if (DyNTS_global_settings.log_settings.setup) {
+      DyFM_Log.log(
+        'Required server connections:', JSON.stringify(this.requiredServerConnections.map(
+          (connection: DyNTS_ServerConnection): { name: string, baseUrl: string, testEndpoint: string } => ({
+            name: connection.name,
+            baseUrl: connection.apiService.baseUrl,
+            testEndpoint: connection.apiService.testEndpoint ?? '',
+          })
+        ), null, 2)
+      );
+    } */
+
+    this.overseer = timer(this.overseerTickTime, this.overseerTickTime).subscribe(async () => {
+      try {
+        await this.triggerCreateSnapshot('overseer-system-tick');
+      } catch (error) {
+        DyFM_Error.logSimple(' ! Error in overseer (server status):', error);
+        DyNTS_GlobalService.globalErrorHandler(
+          new DyFM_Error({
+            ...this.getDefaultErrorSettings('overseer tick', error, 'overseer-system-tick'),
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-OT0`,
+          })
+        ).catch();
+      }
+    });
+  }
+
+  async getServerStatus(issuer: string, clientVersion?: string): Promise<DyFM_ServerStatus> {
+    try {
+      return {
+        status: 'ready',
+
+        systemName: DyNTS_global_settings.systemName,
+        systemShortCode: DyNTS_global_settings.systemShortCodeName,
+
+        clientVersionOk: clientVersion ? this.clientVersionIsLatest(clientVersion) : false,
+        latestClientVersion: this.latestClientVersion,
+        latestClientVersionNumeric: this.latestClientVersionNumeric,
+
+        serverVersion: this.serverVersion,
+        serverNumericVersion: this.serverVersionNumeric,
+        // Az APP sajat verzioja (a serverVersion a bedrock-e) — deploy-verifikaciohoz.
+        appVersion: this.appVersion,
+
+        uptime: +new Date() - +this.up,
+
+        memoryUsage: process.memoryUsage(),
+        cpuUsage: process.cpuUsage(),
+        serverConnections: await this.checkServerConnections(issuer),
+      } 
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getServerStatus', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-GSS0`,
+      });
+    }
+  }
+
+  async checkServerConnections(issuer: string): Promise<DyFM_ServerConnectionCheckResult> {
+    try {
+      const connections: DyFM_ServerConnectionCheckResult = {};
+
+      await DyFM_Array.asyncForEachAllAtOnce(
+        this.requiredServerConnections,
+        async (connection: DyNTS_ServerConnection) => {
+          if (!connection.accessible || Date.now() - connection.lastCheck.getTime() > this.connectionMaxCheckFrequency) {
+            await connection.apiService.checkServerAvailability(issuer).catch((error) => {
+              DyFM_Error.logSimple(
+                `(checkServerConnections) "${connection.name}" server is not available` +
+                `\n    baseUrl: ${connection.apiService.baseUrl}` +
+                `\n    testEndpoint: ${connection.apiService.testEndpoint ?? ''}`, 
+                error
+              );
+              connection.accessible = false;
+            }).then(() => {
+              connection.accessible = true;
+            });
+            connection.accessible = true;
+            connection.lastCheck = new Date();
+          }
+
+          connections[connection.name] = connection.accessible ? DyFM_ServerConnection_Status.accessible : DyFM_ServerConnection_Status.unaccessible;
+        }
+      )
+
+      return connections;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('checkServerConnections', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-CC0`,
+      });
+    }
+  }
+
+  /**
+   * A mongoose default-connection. Külön metódus = teszt-seam (spy-jal felülírható, hogy a
+   * {@link checkDbReadiness} DB nélkül is tesztelhető legyen).
+   */
+  /** BFR-OVERSEER-004 — stats-only DB-diagnosztika a `/server/db-stats` endpointnak (metaadat-only). */
+  async getDbStats(): Promise<DyNTS_DbStats> {
+    return DyNTS_DbStats_Util.collect(this.getMongooseConnection());
+  }
+
+  /** BFR-AM-015 — aggregált doctor-riport a `/server/doctor` endpointnak (sosem dob). */
+  async runDoctor(): Promise<DyNTS_DoctorReport> {
+    return DyNTS_Diagnostics.runDoctor({ connection: this.getMongooseConnection() });
+  }
+
+  protected getMongooseConnection(): mongoose.Connection {
+    // FIX (2026-07-22) — a `mongoose.connection` NEM feltetlenul az a handle, amit a data-layer hasznal.
+    //
+    // ELESBEN MERVE (adventor, a diagnosztikai mezokkel): `dbConnectionCount: 1`, `dbModelCount: 0`,
+    // `dbOtherReadyStates: [1]` — azaz letezik EGY KAPCSOLODOTT (readyState=1) connection, de a
+    // `mongoose.connection` **nem az**: az disconnected (0), NULLA modellel, `host`/`name` nelkul
+    // (sosem csatlakozott). Emiatt a readiness flotta-szinten **hamis 503**-at adott (adventor,
+    // token-service, master-prompter), mikozben a DB vegig egeszseges volt es az appok kiszolgaltak.
+    //
+    // Ezert a valos, KAPCSOLODOTT connectiont keressuk meg a `mongoose.connections`-bol, es csak
+    // fallbackkent hasznaljuk a `mongoose.connection`-t. Ez minden esetben helyes:
+    //  - ha van elo connection -> azt merjuk (readyState=1 + valos ping) -> a readiness igazat mond,
+    //  - ha a DB tenyleg halott -> egyik sem 1 -> fallback -> tovabbra is helyesen NEM-ready.
+    // Vagyis a valodi DB-kiesest NEM maszkolja el, csak a hamis-negativot szunteti meg.
+    const all: mongoose.Connection[] = mongoose.connections ?? [];
+    const live: mongoose.Connection | undefined =
+      all.find((c: mongoose.Connection): boolean => c?.readyState === 1);
+
+    return live ?? mongoose.connection;
+  }
+
+  /**
+   * Readiness-probe: a `/health` (liveness — "a process fut + kiszolgál") MELLETT a DB-elérhetőséget
+   * ellenőrzi. A readyState (mongoose driver-állapot) + egy valós `ping` round-trip → így a "connected
+   * de a DB nem válaszol" eset is kibukik. **Sosem dob** (a probe-nak determinisztikusan kell válaszolnia);
+   * hiba esetén `ready=false`. Az endpoint 503-at adjon, ha nem ready → az orchestrátor (k8s/docker/LB)
+   * ne irányítson forgalmat a DB-vesztett instance-ra.
+   */
+  async checkDbReadiness(): Promise<DyNTS_DbReadiness> {
+    let dbReadyState: number = 0;
+    let dbPingOk: boolean = false;
+
+    try {
+      const connection: mongoose.Connection = this.getMongooseConnection();
+      // readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting
+      dbReadyState = connection?.readyState ?? 0;
+
+      if (dbReadyState === 1) {
+        await connection.db?.admin().ping();
+        dbPingOk = true;
+      }
+    } catch (error) {
+      DyFM_Log.warn('(checkDbReadiness) DB readiness check failed', error);
+      dbPingOk = false;
+    }
+
+    // DIAGNOSZTIKA (2026-07-22): sosem dobhat — a probe-nak determinisztikusan kell válaszolnia,
+    // ezért a diag-gyűjtés SAJÁT try-ban van (ha bármelyik mező kiolvasása elszáll, a readiness
+    // válasz attól még ép marad).
+    let diagnostics: Partial<DyNTS_DbReadiness> = {};
+    try {
+      const conn: mongoose.Connection = this.getMongooseConnection();
+      const all: mongoose.Connection[] = mongoose.connections ?? [];
+
+      diagnostics = {
+        dbConnectionCount: all.length,
+        dbHost: conn?.host,
+        dbName: conn?.name,
+        dbModelCount: Object.keys(conn?.models ?? {}).length,
+        // a default connectiont kihagyjuk — csak a "van-e MÁSIK, élő handle" kérdés érdekes
+        dbOtherReadyStates: all.filter((c: mongoose.Connection): boolean => c !== conn)
+          .map((c: mongoose.Connection): number => c?.readyState ?? -1),
+      };
+    } catch (error) {
+      DyFM_Log.warn('(checkDbReadiness) diagnostics collection failed (non-fatal)', error);
+    }
+
+    return {
+      ready: dbReadyState === 1 && dbPingOk,
+      dbReadyState: dbReadyState,
+      dbPingOk: dbPingOk,
+      uptime: +new Date() - +this.up,
+      serverVersion: this.serverVersion,
+      appVersion: this.appVersion,
+      ...diagnostics,
+    };
+  }
+
+  async getErrorStatistics(
+    range: DyFM_RelativeDate,
+    issuer: string
+  ): Promise<DyFM_Error_Statistics> {
+    try {
+      const error_DS: T_Errors_ControlService = 
+        this.getErrorControlService({ issuer: issuer });
+        /* new DyNTS_Error_DataService({ issuer: issuer }); */
+
+      const from: Date = DyFM_Time.getDateByRelativeDate(range);
+      const errorsPaged: DyFM_Paged<T_Errors> = await error_DS.getErrorsFromDate(from, issuer);
+      const errors: T_Errors[] = errorsPaged.items;
+
+      return {
+        range: range,
+
+        allErrors: errors.length,
+        allAllErrors: errors.reduce(
+          (sum: number, error: T_Errors): number => sum + error.count, 
+          0
+        ),
+
+        serverErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.source.includes('SERVER')
+          ).length,
+        clientErrors:
+          errors.filter(
+            (error: T_Errors): boolean => !error.source.includes('SERVER')
+          ).length,
+        allServerErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.source.includes('SERVER')
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+        allClientErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => !error.source.includes('SERVER')
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+
+        infoErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
+          ).length,
+        warningErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
+          ).length,
+        errorErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
+          ).length,
+        criticalErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
+          ).length,
+
+        allInfoErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+        allWarningErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+        allErrorErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+        allCriticalErrors: 
+          errors.filter(
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
+          ).reduce(
+            (sum: number, error: T_Errors): number => sum + error.count, 0
+          ),
+      } as DyFM_Error_Statistics;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getMatchStatistics',
+          error?.response?.data ?? error,
+          issuer
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSS-GES0`,
+      });
+    }
+  }
+
+  protected getVersionNumeric(version: string): number {
+    return +version.replace('v', '')
+      .replace('.', '')
+      .replace('.', '')
+      .replace('-alpha', '')
+      .replace('-beta', '')
+      .replace('-test', '')
+      .replace('-dev', '');
+  }
+
+  protected clientVersionIsLatest(clientVersion: string): boolean {
+    const thisClientVersionNumeric: number = this.getVersionNumeric(clientVersion);
+
+    if (!this._latestClientVersionNumeric) {
+      this.setLatestClientVersion(clientVersion, thisClientVersionNumeric);
+
+      return true;
+
+    } else if (thisClientVersionNumeric === this._latestClientVersionNumeric) {
+      return true;
+
+    } else if (thisClientVersionNumeric < this._latestClientVersionNumeric) {
+      return false;
+
+    } else if (this._latestClientVersionNumeric < thisClientVersionNumeric) {
+      this.setLatestClientVersion(clientVersion, thisClientVersionNumeric);
+
+      return true;
+    }
+
+    DyFM_Log.error(
+      'Something went wrong, invalid version:', clientVersion,
+      thisClientVersionNumeric, _serverVersion, this.serverVersionNumeric
+    );
+
+    return false;
+  }
+
+  protected setLatestClientVersion(clientVersion: string, clientVersionNumeric: number): void {
+    if (!clientVersion.includes('test') && !clientVersion.includes('dev')) {
+      this._latestClientVersion = clientVersion;
+      this._latestClientVersionNumeric = clientVersionNumeric;
+    }
+  }
+
+  protected async triggerCreateSnapshot(issuer: string): Promise<void> {
+    try {
+      const snapshot: T_ServerStatusSnapshot = await this.getServerStatusSnapshot(issuer);
+      const serverStatusSnapshot_CS: T_ServerStatusSnapshot_ControlService = 
+        this.getServerStatusSnapshotControlService({ issuer: issuer });
+
+      await serverStatusSnapshot_CS.saveSnapshot(snapshot, issuer);
+
+      DyFM_Log.info('ServerStatus snapshot created');
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('triggerCreateSnapshot', error, 'system-tick'),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-TCS0`,
+      });
+    }
+  }
+
+  async getServerStatusSnapshot(issuer: string): Promise<T_ServerStatusSnapshot> {
+    try {
+      return ({
+        ...(await this.getServerStatus(issuer)),
+      }) as T_ServerStatusSnapshot;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getServerStatusSnapshot',
+          error?.response?.data ?? error,
+          issuer
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSCS-GSS0`,
+      });
+    }
+  }
 }