@futdevpro/nts-dynamo 1.10.10 → 1.10.12

package/src/_modules/server/error/error.data-service.ts

@@ -0,0 +1,337 @@
+
+
+
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+
+import {
+  DyFM_AnyError,
+  DyFM_DBFilter,
+  DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
+  DyFM_Log, DyFM_Shared, DyFM_clone, DyFM_errorFlag, DyFM_Errors
+} from '@futdevpro/fsm-dynamo';
+
+
+export class DyNTS_Error_DataService<
+  T_Error extends DyFM_Errors
+> extends DyNTS_DataService<T_Error> {
+
+  debugLog: boolean = false;
+  readonly version: string = DyNTS_global_settings.systemVersion;
+  protected duplicationCounter: number;
+
+  /* constructor(
+    set: {
+      data?: T_Error,
+      issuer: string,
+    },
+    dataParams: DyFM_DataModel_Params<T_Error>
+  ) {
+    super(
+      new FDP_Error(set?.data) as T_Error,
+      dataParams,
+      set.issuer
+    );
+  } */
+
+  async recordError(data?: T_Error, alwaysRecord?: boolean): Promise<void> {
+    try {
+      if (
+        !alwaysRecord &&
+        this.data?.version?.includes('dev') || 
+        this.data?.version?.includes('alpha') || 
+        this.data?.version?.includes('beta')
+      ) {
+        DyFM_Log.warn('error not saved (dev version)');
+
+        return;
+      }
+
+      if (!data && this.data) {
+        data = this.data;
+      }
+
+      if (!data) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'recordError',
+            new Error('error data is not defined')
+          ),
+  
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE1`,
+        });
+      }
+
+      if ([ DyFM_ErrorLevel.user ].includes(data.level)) {
+        DyFM_Log.warn('error not saved (user level)');
+
+        return;
+      }
+
+      if (data.message?.includes('NullReferenceException')) {
+        data.message += '\n' + data.exception.split('() (at <')[0];
+      }
+
+      const duplicateError: T_Error = await this.findData({
+        version: data.version,
+        message: data.message,
+      } as DyFM_DBFilter<T_Error>, true);
+
+      data.d_error = this.checkErrorIsStringifyableOrResolvable(data.d_error) as DyFM_Error;
+      
+      try {
+        JSON.stringify(data);
+      } catch (err) {
+        DyFM_Log.error('error data is not stringifyable!');
+
+        return;
+      }
+
+      if (JSON.stringify(data).length > 16793000) {
+        data.additionalContent = {
+          message: 'error data was too big to save, removed additionalContent',
+        };
+        data.error.additionalContent = {
+          message: 'error data was too big to save, removed additionalContent',
+        };
+
+        if (JSON.stringify(data).length > 16793000) {
+          data.error.errors = [];
+        }
+      }
+
+      if (
+        duplicateError && 
+        duplicateError?.message === data?.message
+      ) {
+        if (!data.__created) {
+          data.__created = new Date();
+        }
+
+        this.duplicationCounter = duplicateError.count + 1;
+
+        await this.updateData({
+          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_Error>,
+          update: { 
+            $inc: { count: 1, priority: this.getPriorityMultiplierByLevel(data?.level) },
+          } as DyNTS_DBUpdate<T_Error>,
+        });
+
+        // ezt majd ha leülepedett, hogy biztos nem kellenek a deep duplication-ök 
+        // (a WB-ban kellhettek a user és pc config info-k)
+        /* if (!duplicateError.duplications.includes(data.stackTrace)) {
+          await this.updateData({
+            filterBy: { _id: duplicateError._id } as DyFM_DBFilter<Error_T>,
+            update: { 
+              $push: { duplications: DyFM_clone(data) },
+            } as DyNTS_DBUpdate<Error_T>,
+          }).catch((pushError) => {
+            DyFM_Log.error('pushError:', pushError);
+          });
+        } */
+
+        DyFM_Log.error(
+          'error found, not saving ("known" error), but increased count, ' +
+          '\ncount:', duplicateError.count + 1
+        );
+        DyFM_Log.error(
+          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+        );
+
+        if (this.debugLog) DyFM_Log.error('Error:', data);
+      } else {
+        DyFM_Log.log('error not found, saving....');
+        DyFM_Log.error(
+          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+        );        
+
+        if (this.debugLog) DyFM_Log.error('Error:', data);
+
+        data.priority = this.getPriorityMultiplierByLevel(data?.level);
+        data.duplications.push(DyFM_clone(data));
+
+        this.duplicationCounter = 1;
+
+        await this.saveData();
+        DyFM_Log.warn('error saved');
+      }
+    } catch (error) {
+      DyFM_Log.error('recordError error:', error);
+      /* throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'recordError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE0`,
+      }); */
+    }
+  }
+
+  async preProcessWBError(): Promise<void> {
+    try {
+      const innerError = this.data?.error;
+
+      if (
+        innerError && 
+        !innerError?.message &&
+        !innerError?.userMessage &&
+        !innerError?.d_error?.message &&
+        !innerError?.d_error?.userMessage
+      ) {
+        delete this.data.error;
+      }
+
+      const innerDError: DyFM_Error = this.data?.d_error;
+
+      if (
+        innerDError && 
+        !innerDError?._message &&
+        !innerDError?.__userMessage &&
+        !innerDError?._errorCode
+      ) {
+        delete this.data.d_error;
+      }
+
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'preProcessWBError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-PPE0`,
+      });
+    }
+  }
+
+  async handleInternalError(
+    error: DyFM_AnyError | any, 
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void> {
+    try {    
+      if (this.debugLog) DyFM_Log.log('handleInternalError');
+
+      if ((error as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
+        this.data = new DyFM_Errors({
+          issuer: issuer,
+          version: 'SERVER-' + this.version,
+
+          source: 'INTERNAL-SERVER-ERROR: ' + (error as DyFM_Error)?.___issuerService,
+
+          stackTrace: (error as DyFM_Error)?._errorCodes,
+          error: (error as DyFM_Error)?.getErrorSimplified?.(),
+          level: (error as DyFM_Error)?.level ?? DyFM_ErrorLevel.error,
+
+          message: (error as DyFM_Error)?._message,
+          exceptionObj: 
+            (error as DyFM_Error)?.errors?.map(
+              (e: DyFM_Error): DyFM_Error_Settings | ''  => e?.getErrorSimplified?.() ?? ''
+            ),
+
+          additionalContent: (error as DyFM_Error)?.additionalContent,
+        }) as T_Error;       
+      } else {
+        this.data = new DyFM_Errors({
+          issuer: issuer,
+          version: 'SERVER-' + this.version,
+
+          source: 'UNEXPECTED-SERVER-ERROR',
+
+          stackTrace: (error as Error)?.stack.split('\n'),
+          error: error,
+          level: DyFM_ErrorLevel.critical,
+
+          message: (error as Error)?.message,
+          exceptionObj: (error as Error)?.stack?.split('\n'),
+        }) as T_Error;
+      }
+
+      /* if (!(error as FDP_Error)?.flag?.includes('WB-ERROR-OBJECT')) {
+        DyFM_Log.H_error('__ERROR__:', error);
+      } */
+
+      await this.recordError(this.data, alwaysRecord);
+
+      if (
+        DyNTS_global_settings.log_settings.highDetailedLogs ||
+        !(error instanceof DyFM_Error)
+      ) {
+        DyFM_Log.H_error(
+          `FDPNTS_Error_DataService handling InternalError...`,
+          `\n    ERROR:`, error
+        );
+      } else {
+        error.logSimple(
+          `FDPNTS_Error_DataService handling InternalError...`
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('handleInternalError error:', error);
+      /* throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'handleInternalError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-HIE0`,
+      }); */
+    }
+  }
+
+  private checkErrorIsStringifyableOrResolvable(error: DyFM_Error): DyFM_Error | 'UNRESOLVABLE' {
+    try {
+      JSON.stringify(error);
+    } catch (err) {
+      DyFM_Log.error('error data is not stringifyable! trying to resolve...');
+
+      error = DyFM_Shared.resolveCirculation(error) as DyFM_Error;
+
+      try {
+        JSON.stringify(error);
+      } catch (err) {
+        delete error.additionalContent;
+
+        try {
+          JSON.stringify(error);
+        } catch (err) {
+          DyFM_Log.error('error data is not stringifyable! resolution failed! will not save!');
+
+          return 'UNRESOLVABLE';
+        }
+
+        DyFM_Log.error('error data was too big to save, removed additionalContent');
+      }
+    }   
+
+    return error;
+  }
+
+  private getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number {
+    switch (level) {
+      case DyFM_ErrorLevel.critical: 
+      case DyFM_ErrorLevel.fatal:
+        return 1000;
+
+      case DyFM_ErrorLevel.error:
+      case DyFM_ErrorLevel.serious:
+        return 100;
+
+      case DyFM_ErrorLevel.warning: 
+        return 10;
+
+      case DyFM_ErrorLevel.info: 
+      case DyFM_ErrorLevel.debug:
+      case DyFM_ErrorLevel.known:
+        return 0.01;
+
+      case DyFM_ErrorLevel.user:        
+      default: 
+        return 0;
+    }
+  }
+
+}

package/src/_modules/server/index.ts

@@ -0,0 +1,11 @@
+
+// ERROR
+export * from './error/error.controller';
+export * from './error/error.data-service';
+
+// SERVER-STATUS
+export * from './server-status/server-status.control-service';
+export * from './server-status/server-status.controller';
+
+
+

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,
+  T_ServerStatus extends 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,105 @@
+
+import { Request, Response } from 'express';
+
+import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate, DyFM_ServerStatus } 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';
+
+
+/**
+ * Endpoints:
+ * 
+ * getServerStatus
+ * GET /status
+ * 
+ * getServerStatusForClient
+ * GET /status/:version
+ * 
+ * getErrorStatistics
+ * GET /statistics/error/:range
+ * 
+ */
+export abstract class DyNTS_ServerStatus_Controller<
+  T_Error extends DyFM_Errors,
+  T_ServerStatus extends DyFM_ServerStatus,
+  T_ServerStatusService extends DyNTS_ServerStatus_ControlService<T_Error, T_ServerStatus>
+> 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';