@futdevpro/nts-dynamo 1.10.9 → 1.10.11

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

@@ -0,0 +1,217 @@
+
+
+import { 
+  DyFM_Metadata, DyFM_RelativeDate, DyFM_Time, DyFM_ServerStatus, DyFM_ErrorLevel, DyFM_Log, 
+  DyFM_Error, DyFM_Error_Statistics, DyFM_Errors 
+} from '@futdevpro/fsm-dynamo';
+
+import { version as _serverVersion } from '../../../../package.json';
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Error_DataService } from '../error/error.data-service';
+
+export abstract class DyNTS_ServerStatus_ControlService<
+  T_Error extends DyFM_Errors = DyFM_Errors,
+  T_ServerStatus extends DyFM_ServerStatus = DyFM_ServerStatus
+> extends DyNTS_SingletonService {
+
+  /* static getInstance(): FDPNTS_ServerStatus_ControlService {
+    return FDPNTS_ServerStatus_ControlService.getSingletonInstance();
+  } */
+
+  /* protected constructor() {
+    super();
+
+    if (!this.getErrorDataService) {
+      throw new DyFM_Error({
+        message: 'getErrorDataService() method not implemented in ServerStatus_ControlService.',
+        status: 500,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSS-GED0',
+      });
+    }
+  } */
+
+  protected abstract getErrorDataService?(
+    set?: { data?: T_Error, issuer?: string }
+  ): DyNTS_Error_DataService<T_Error>;
+
+  /* protected abstract error_DS: FDPNTS_Error_DataService<T_Error>; */
+
+  protected readonly up: Date = new Date();
+
+  protected readonly _serverVersionNumeric: number = this.getVersionNumeric(_serverVersion);
+  get serverVersion(): string { return _serverVersion; }
+  get serverVersionNumeric(): number { return this._serverVersionNumeric; }
+
+  protected _latestClientVersion: string;
+  protected _latestClientVersionNumeric: number;
+  get latestClientVersion(): string { return this._latestClientVersion; }
+  get latestClientVersionNumeric(): number { return this._latestClientVersionNumeric; }
+
+  override readonly defaultErrorUserMsg = 'Something went wrong';
+
+  /* private readonly serverSnapshotOverseer  */
+
+  getServerStatus(clientVersion?: string): DyFM_ServerStatus {
+    return {
+      status: 'ready',
+
+      clientVersionOk: clientVersion ? this.clientVersionIsLatest(clientVersion) : false,
+      latestClientVersion: this.latestClientVersion,
+      latestClientVersionNumeric: this.latestClientVersionNumeric,
+
+      serverVersion: this.serverVersion,
+      serverNumericVersion: this.serverVersionNumeric,
+
+      uptime: +new Date() - +this.up,
+
+      memoryUsage: process.memoryUsage(),
+      cpuUsage: process.cpuUsage(),
+    } 
+  }
+
+  async getErrorStatistics(
+    range: DyFM_RelativeDate,
+    issuer: string
+  ): Promise<DyFM_Error_Statistics> {
+    try {
+      const error_DS: DyNTS_Error_DataService<T_Error> = 
+        this.getErrorDataService({ issuer: issuer });
+        /* new FDPNTS_Error_DataService({ issuer: issuer }); */
+
+      const from: Date = DyFM_Time.getDateByRelativeDate(range);
+      const errors: T_Error[] = await error_DS.findDataList({ 
+        __created: { $gte: from },
+      });
+
+      return {
+        range: range,
+
+        allErrors: errors.length,
+        allAllErrors: errors.reduce(
+          (sum: number, error: T_Error): number => sum + error.count, 
+          0
+        ),
+
+        serverErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.source.includes('SERVER')
+          ).length,
+        clientErrors:
+          errors.filter(
+            (error: T_Error): boolean => !error.source.includes('SERVER')
+          ).length,
+        allServerErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.source.includes('SERVER')
+          ).reduce(
+            (sum: number, error: T_Error): number => sum + error.count, 0
+          ),
+        allClientErrors: 
+          errors.filter(
+            (error: T_Error): boolean => !error.source.includes('SERVER')
+          ).reduce(
+            (sum: number, error: T_Error): number => sum + error.count, 0
+          ),
+
+        infoErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.info
+          ).length,
+        warningErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.warning
+          ).length,
+        errorErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.error
+          ).length,
+        criticalErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.critical
+          ).length,
+
+        allInfoErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.info
+          ).reduce(
+            (sum: number, error: T_Error): number => sum + error.count, 0
+          ),
+        allWarningErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.warning
+          ).reduce(
+            (sum: number, error: T_Error): number => sum + error.count, 0
+          ),
+        allErrorErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.error
+          ).reduce(
+            (sum: number, error: T_Error): number => sum + error.count, 0
+          ),
+        allCriticalErrors: 
+          errors.filter(
+            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.critical
+          ).reduce(
+            (sum: number, error: T_Error): 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}|FDPNTS-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;
+    }
+  }
+}

package/src/_modules/server/server-status/server-status.controller.ts

@@ -0,0 +1,90 @@
+
+import { Request, Response } from 'express';
+
+import { DyFM_Error, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
+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';
+
+
+export abstract class DyNTS_ServerStatus_Controller<
+  T_ServerStatusService extends DyNTS_ServerStatus_ControlService = any
+> extends DyNTS_Controller {
+
+  /* static getInstance(): FDPNTS_ServerStatus_Controller {
+    return FDPNTS_ServerStatus_Controller.getSingletonInstance();
+  } */
+
+  protected abstract readonly server_CS: T_ServerStatusService;
+  
+  /* protected abstract getServerService(): T_ServerStatusService; */
+  protected readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
+
+  setupEndpoints(): void {
+    /* if (!this.getServerService) {
+      throw new DyFM_Error({
+        message: 'getServerService() method not implemented in ServerStatus_Controller.',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSC-001`,
+      });
+    } */
+
+    if (!this.additionalEndpoints) {
+      throw new DyFM_Error({
+        message: 'additionalEndpoints must be defined in ServerStatus_Controller.',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSC-002`,
+      });
+    }
+
+    /* this.serverService = this.getServerService(); */
+
+    this.endpoints = [
+      new DyNTS_Endpoint_Params({
+        name: 'getServerStatus',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/status',
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send(
+              this.server_CS.getServerStatus()
+            );
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'getServerStatusForClient',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/status/:version',
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+
+            res.send(
+              this.server_CS.getServerStatus(req.params.version)
+            );
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'getErrorStatistics',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/statistics/error/:range',
+        tasks: [
+          async (req: Request, res: Response, issuer: string) : Promise<void> => {
+
+            res.send(
+              await this.server_CS.getErrorStatistics(
+                req.params.range as DyFM_RelativeDate,
+                issuer
+              )
+            );
+          },
+        ],
+      }),
+
+      ...this.additionalEndpoints,
+    ];
+  }
+}
+

package/src/_modules/socket/_services/socket-server.service.ts

@@ -20,7 +20,6 @@ import {
 import {
   DyNTS_SocketServerService_Params
 } from '../_models/socket-server-service-params.control-model';
-import { DyNTS_getStackLocation } from '../../../_collections/stack.util';
 
 /**
  * You need to define the following functions:

package/src/_modules/socket/index.ts

@@ -16,4 +16,4 @@ export * from './_services/socket-client.service';
 export * from './_services/socket-server.service';
 export * from './app-extended.server';
 
-
+export * from '@futdevpro/fsm-dynamo/socket';