@nsshunt/stsappframework 3.1.235 → 3.1.237

package/src/process/processbase.ts

@@ -1,483 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import pidusage from 'pidusage'
-import { memoryUsage } from 'process'
-import cluster from 'node:cluster'
-import si from 'systeminformation' // https://systeminformation.io/
-import { GetFirstNetworkInterface } from './../network'
-
-import chalk from 'chalk';
-
-import { Gauge, InstrumentBaseTelemetry, InstrumentGaugeTelemetry, InstrumentObjectTelemetry, InstrumentLogTelemetry } from '@nsshunt/stsobservability'
-
-import { IDBAccessLayer, accessLayerType, DBAccessLayerManager, IDBAccessLayerEvents } from '@nsshunt/stsdatamanagement'
-
-import { goptions } from '@nsshunt/stsconfig'
-
-import { JSONObject } from '@nsshunt/stsutils'
-import { StatusCodes } from 'http-status-codes'
-
-import { PublishInstrumentController, IPublishInstrumentControllerOptions, InstrumentDefinitions, 
-    TransportType, IPublishTransportRESTServerOptions, GetInstruments } from '@nsshunt/stsobservability'
-
-import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketioutils'
-import os from 'os';
-
-import { IProcessBase, CreateServiceProcessContext, ProcessOptions, IProcessBaseEvents } from './../commonTypes'
-
-import { TinyEmitter } from 'tiny-emitter';
-
-import { ISocketIoServerHelper } from '@nsshunt/stssocketioutils'
-
-export abstract class ProcessBase extends TinyEmitter implements IProcessBase 
-{
-    #options: ProcessOptions;
-    #instrumentController: PublishInstrumentController | null = null;
-    #systemInformationInterval: NodeJS.Timeout | null = null;
-    #socketIoServerHelper: ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null = null;
-    #accessLayer: IDBAccessLayer | null = null;
-    //#redisMessageHandler: RedisMessageHandler | null = null;
-
-    constructor(options: ProcessOptions) {
-        super();
-        this.#options = options;
-
-        if (options.serviceName) {
-            this.options.serviceProcessContext = CreateServiceProcessContext(options.serviceName, options.serviceVersion, options.serviceInstanceId,
-                os.hostname(), process.pid, options.isMaster ? process.pid : process.ppid)
-        }
-    }
-
-    #GetFormattedLogMessage(message: string): string {
-        let prefix = '';
-        let col = null;
-        const appName = this.options.serviceName;
-
-        if (cluster.isPrimary) {
-            prefix = 'M';
-            col = chalk.bold.cyan;
-        } else {
-            prefix = 'W';
-            col = chalk.green;
-        }
-        return col(`${prefix}(${process.pid}) [${appName}]: ${message}`);
-    }
-
-    LogErrorMessage(message: any) {
-        this.options.logger.error(this.#GetFormattedLogMessage(message));
-    }
-
-    LogInfoMessage(message: any) {
-        this.options.logger.info(this.#GetFormattedLogMessage(message));
-    }
-
-    LogMessageToLoggerInstrument(message: any) {
-        this.UpdateInstrument(Gauge.LOGGER, {
-            LogMessage: this.#GetFormattedLogMessage(message)
-        } as InstrumentLogTelemetry);
-    }
-
-    get options(): ProcessOptions {
-        return this.#options as ProcessOptions;
-    }
-
-    get shuttingDown(): boolean {
-        return false;
-    }
-
-    SetupInstrumentation()
-    {
-        if (!this.options.serviceProcessContext) {
-            return;
-        }
-
-        let publishTransportOptions: IPublishTransportRESTServerOptions | null = null;
-        if (goptions.observabilityPublishMode.localeCompare('PROXY') === 0) {
-            publishTransportOptions = {
-                transportType: TransportType.RESTAPI,
-                url: `${goptions.imendpoint}:${goptions.import}${goptions.imapiroot}/publishmessage`,
-                // socketPath: '/var/run/sts/stsrest01.sock'
-                agentOptions: {
-                    keepAlive: goptions.keepAlive,
-                    maxSockets: goptions.maxSockets,
-                    maxTotalSockets: goptions.maxTotalSockets,
-                    maxFreeSockets: goptions.maxFreeSockets,
-                    timeout: goptions.timeout,
-                    rejectUnauthorized: goptions.isProduction // Allows self signed certs in non production mode(s)
-                },
-                logger: this.options.publisherLogger
-            };
-        } else {
-            // Currently, now other types are supported
-            return;
-        }
-
-        const httpServer: boolean = (goptions.STSServerType.localeCompare('EXPRESS') === 0) || (goptions.STSServerType.localeCompare('EXPRESS_TLS') === 0);
-
-        //const fileName = './dist/publishInstrumentsWebWorker.js';
-        //const worker = new Worker(fileName);
-
-        const instrumentControllerOptions: IPublishInstrumentControllerOptions = {
-
-            processContext: this.options.serviceProcessContext,
-            //payloadType: InstrumentPayloadType.service,
-            consoleLogging: this.options.consoleLogging,
-            instrumentLogging: this.options.instrumentLogging,
-            httpServer,
-            instrumentationObservationInterval: this.options.instrumentationObservationInterval,
-            instrumentationTimeWindow: this.options.instrumentationTimeWindow,
-            logger: this.options.publisherLogger,
-            publishInterval: this.options.publishInterval,
-            publishPostFailInterval: 5000, //@@
-            instrumentDefinitions: GetInstruments('service'),
-            publishTransportBaseOptions: publishTransportOptions,
-            autoStart: true
-            /*
-            [
-                ...this.#GetDefaultServiceInstruments(httpServer),
-                ...this.GetAdditionalInstruments()
-            ]
-            */
-        }
-
-        this.#instrumentController = new PublishInstrumentController(instrumentControllerOptions);
-    }
-
-    /*
-    #GetDefaultServiceInstruments(httpServer: boolean): InstrumentDefinitions {
-        const standardInstruments: InstrumentDefinitions = [
-            [ Gauge.TIMER_GAUGE, GaugeTypes.INSTRUMENT_TIMER ],
-            [ Gauge.LOGGER, GaugeTypes.INSTRUMENT_LOG, {
-                consoleLogging: this.options.consoleLogging,
-                instrumentLogging: this.options.instrumentLogging } as InstrumentLogOptions],
-            [ Gauge.NETWORK_RX_GAUGE , GaugeTypes.INSTRUMENT_VELOCITY ],
-            [ Gauge.NETWORK_TX_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ],
-            [ Gauge.CPU_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                interval: this.options.instrumentationObservationInterval, 
-                sampleSize: this.options.instrumentationTimeWindow } as InstrumentGaugeOptions],
-            [ Gauge.OBJECT_GAUGE, GaugeTypes.INSTRUMENT_OBJECT, {
-                label:'InstrumentObjectMaster' } as InstrumentObjectOptions]
-        ];
-
-        let httpServerInstruments: InstrumentDefinitions = [ ];
-        if (httpServer) {
-            httpServerInstruments = [
-                [ Gauge.REQUEST_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of requests serviced
-                [ Gauge.AUTHENTICATION_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests
-                [ Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests errors
-                [ Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests retries
-
-                [ Gauge.ACTIVE_REQUEST_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                    interval: this.options.instrumentationObservationInterval, 
-                    sampleSize: this.options.instrumentationTimeWindow } as InstrumentGaugeOptions],
-                [ Gauge.DURATION_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                    interval: this.options.instrumentationObservationInterval,
-                    sampleSize: this.options.instrumentationTimeWindow } as InstrumentGaugeOptions],
-                [ Gauge.DURATION_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
-                [ Gauge.CONNECTION_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, { 
-                    interval: this.options.instrumentationObservationInterval, 
-                    sampleSize: this.options.instrumentationTimeWindow } as InstrumentGaugeOptions],
-    
-                [ Gauge.CONNECTION_POOL_TOTAL_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
-                [ Gauge.CONNECTION_POOL_IDLE_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
-                [ Gauge.CONNECTION_POOL_WAITING_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
-                [ Gauge.VELOCITY_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ], // Requests per second
-                [ Gauge.ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
-                [ Gauge.RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
-                [ Gauge.LATENCY_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                    interval: this.options.instrumentationObservationInterval,
-                    sampleSize: this.options.instrumentationTimeWindow } as InstrumentGaugeOptions],
-                [ Gauge.LATENCY_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
-                [ Gauge.CORE_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ]
-            ]
-        }
-        return [
-            ...standardInstruments,
-            ...httpServerInstruments
-        ]
-    }
-    */
-
-    GetAdditionalInstruments(): InstrumentDefinitions {
-        return [ ];
-    }
-
-    CollectAdditionalTelemetry(): void { // eslint-disable @typescript-eslint/no-empty-function
-        
-    }
-
-    ProcessStartup = () => {
-        // use this as well
-        // performance.eventLoopUtilization([utilization1[, utilization2]])
-        // https://nodejs.org/api/perf_hooks.html#perf_hooksmonitoreventloopdelayoptions
-
-        const ExecuteGetStats = async () => {
-            const startTime = performance.now();
-
-            if (this.#instrumentController) {
-                const stats = await pidusage(process.pid);
-                let useStatsCpu = stats.cpu;
-                if (useStatsCpu < 0.01) {
-                    useStatsCpu = 0.01; //@@ Endure we record something about 0. 0's are filtered from monitoring tools.
-                }
-                this.#instrumentController.UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
-                    val: useStatsCpu
-                } as InstrumentGaugeTelemetry);
-            };
-
-            /*
-            pidusage(process.pid, (err, stats) => {
-                if (this.#instrumentController) {
-                    let useStatsCpu = stats.cpu;
-                    if (useStatsCpu < 3) {
-                        useStatsCpu = 3; //@@ Endure we record something about 0. 0's are filtered from monitoring tools.
-                    }
-                    this.#instrumentController.UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
-                        val: useStatsCpu
-                    } as InstrumentGaugeTelemetry);
-                }
-            });
-            */
-
-            // https://nodejs.org/api/process.html#processmemoryusage
-            const usage = memoryUsage();
-            const telemetry: JSONObject = {
-                r: usage.rss,
-                t: usage.heapTotal,
-                u: usage.heapUsed,
-                x: usage.external,
-                a: usage.arrayBuffers,
-            }
-
-            this.UpdateInstrument(Gauge.OBJECT_GAUGE, {
-                val: telemetry
-            } as InstrumentObjectTelemetry);
-
-            this.CollectAdditionalTelemetry();
-
-            const totalTime = performance.now() - startTime;
-            const nextLoopTime = goptions.systemInformationInterval - totalTime;
-
-            this.#systemInformationInterval = setTimeout(ExecuteGetStats, nextLoopTime).unref();
-        }
-
-        this.#systemInformationInterval = setTimeout(ExecuteGetStats, goptions.systemInformationInterval).unref();
-
-        if (this.options.useDatabase) {
-            // Get the accessLayer to force DB connection test
-            const accessLayer = this.accessLayer;
-        }
-
-        //@@this.LogInfoMessage(`RedisMessageHandler: redisUrl: [${goptions.imRedisMessageProcessorUrl}]`);
-    }
-
-    UpdateInstrument = (instrumentName: Gauge, telemetry: InstrumentBaseTelemetry) => {
-        if (this.#instrumentController) {
-            this.#instrumentController.UpdateInstrument(instrumentName, telemetry);
-        }
-    }
-
-    ProcessExit = (processExitDelay: number) => {
-        if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
-            setTimeout(() => {
-                this.LogInfoMessage(`Performing process.exit(0).`);
-                process.exit(0);
-            }, processExitDelay); // Give the workers time to terminate gracefully
-        } else {
-            this.LogInfoMessage(`Performing process.exit(0) - Immediate.`);
-        }
-    }
-
-    TerminateInstrumentController = () => {
-        if (this.InstrumentController) {
-            this.LogInfoMessage(`ProcessBase:TerminateInstrumentController()`);
-            setTimeout(() => {
-                if (this.InstrumentController) {
-                    this.InstrumentController.EndPublish();
-                }
-            }, 100);
-        }
-    }
-
-    get InstrumentController(): PublishInstrumentController | null {
-        return this.#instrumentController;
-    }
-
-    InstrumentExists(instrumentName: Gauge): boolean
-    {
-        if (this.#instrumentController) {
-            return this.#instrumentController.InstrumentExists(instrumentName);
-        }
-        return false;
-    }
-
-    TerminateUIController = () => {
-        if (this.GetUIController() !== null) {
-            this.LogInfoMessage('ProcessBase:TerminateUIController(): Destroy the user interface controller.');
-            this.GetUIController().DestroyUI();
-        }
-    }
-
-    async ProcessTerminate(): Promise<void> {
-        this.emit('ProcessTerminate');
-
-        if (this.#systemInformationInterval) {
-            clearTimeout(this.#systemInformationInterval);
-        }
-        this.#systemInformationInterval = null;
-
-        //@@this.#redisMessageHandler?.Stop();
-    }
-
-    /**
-	 * UIController (instance of UIController) to manage a console based user interface associated for this node application.
-	 * @returns UIController instance to manage a console based user interface associated for this node application.
-	 */
-    GetUIController(): any {
-        return null;
-    }
-
-    get socketIoServerHelper(): ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null
-    {
-        return this.#socketIoServerHelper;
-    }
-
-    set socketIoServerHelper(value: ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null)
-    {
-        this.#socketIoServerHelper = value;
-    }
-
-    #UpdatePGPoolManagerInstrument = (data: any) => {
-        this.UpdateInstrument(Gauge.CONNECTION_POOL_TOTAL_GAUGE, {
-            val: data.totalCount
-        } as InstrumentGaugeTelemetry);
-
-        this.UpdateInstrument(Gauge.CONNECTION_POOL_IDLE_GAUGE, {
-            val: data.idleCount
-        } as InstrumentGaugeTelemetry);
-
-        this.UpdateInstrument(Gauge.CONNECTION_POOL_WAITING_GAUGE, {
-            val: data.waitingCount
-        } as InstrumentGaugeTelemetry);
-    }
-
-    async TerminateDatabase(): Promise<void> {
-        if (this.#accessLayer) {
-            const logPrefix = `ProcessBase:TerminateDatabase():${process.pid}:`;
-            this.LogInfoMessage(`${logPrefix} Ending database connections and pools.`);
-            this.#accessLayer.off(IDBAccessLayerEvents.UpdateInstruments, this.#UpdatePGPoolManagerInstrument)
-            await this.#accessLayer.EndDatabase();
-        }
-    }
-
-    get accessLayer(): IDBAccessLayer | null
-    {
-        if (this.options.useDatabase) {
-            if (this.#accessLayer === null) {
-
-                this.#accessLayer = new DBAccessLayerManager().CreateAccessLayer({
-                    accessLayerType: accessLayerType.postgresql,
-                    accessLayerOptions: {
-                        logger: this.options.logger,
-                        usedefaultdb: false
-                    }
-                });
-                
-                this.#accessLayer.on(IDBAccessLayerEvents.UpdateInstruments, this.#UpdatePGPoolManagerInstrument);
-
-                (async () => {
-                    try {
-                        const retVal = await (this.accessLayer as IDBAccessLayer).GetResourceCount();
-                        if (retVal.status !== StatusCodes.OK) {
-                            this.LogInfoMessage(chalk.red(`Unable to get resources from the database. Is the database running? [${JSON.stringify(retVal)}]`));
-                        } else {
-                            this.LogInfoMessage(chalk.green(`Database connection successful. Resources: [${retVal.detail}]`));
-                        }
-                    } catch (error) {
-                        this.LogInfoMessage(chalk.red(`Unable to get resources from the database. Is the database running? Error: [${error}]`));
-                    }
-                })();
-            }
-            return this.#accessLayer;
-        }
-        return null;
-    }
-
-    GetNumCPUs = async (): Promise<number> => {
-        // https://systeminformation.io/
-        const valueObject = {
-            cpu: '*'
-        }
-
-        const sysinfo = await si.get(valueObject);
-        let numCPUs = 2;
-        if (goptions.useCPUs > 0) {
-            if (goptions.useCPUs >= 1) {
-                numCPUs = goptions.useCPUs;
-            } else {
-                numCPUs = Math.round(sysinfo.cpu.cores * goptions.useCPUs);
-            }
-        } else {
-            numCPUs = sysinfo.cpu.physicalCores;
-        }
-        return numCPUs;
-    }
-
-    LogSystemTelemetry = async () => {
-        // https://systeminformation.io/
-        const valueObject = {
-            system: '*',
-            osInfo: '*',
-            cpu: '*',
-            mem: '*'
-        }
-
-        const sysinfo = await si.get(valueObject);
-        const numCPUs = await this.GetNumCPUs();
-        const hostname = sysinfo.osInfo.hostname;
-
-        const hostaddr = GetFirstNetworkInterface();
-        if (hostaddr !== null) {
-            this.LogInfoMessage(`Host Address: ${hostaddr}`);
-        } else {
-            this.LogInfoMessage(`Unknown Host Address.`);
-        }
-        this.LogInfoMessage(`Server starting with ${numCPUs} Cores/Threads`);
-
-        this.LogInfoMessage(`Hostname: ${hostname}`);
-        this.LogInfoMessage(`System: ${JSON.stringify(sysinfo.system)}`);
-        this.LogInfoMessage(`OS Info: ${JSON.stringify(sysinfo.osInfo)}`);
-        this.LogInfoMessage(`CPU: ${JSON.stringify(sysinfo.cpu)}`);
-        this.LogInfoMessage(`Memory: ${JSON.stringify(sysinfo.mem)}`);
-    }
-
-    GetSignalColour = (signal: any) => {
-        let msgcolor = null;
-        if (signal === 'SIGINT') {
-            msgcolor = chalk.yellow;
-        } else {
-            msgcolor = chalk.red;
-        }
-        return msgcolor;
-    };
-
-    emit<K extends keyof IProcessBaseEvents>(event: K, ...arg: IProcessBaseEvents[K]): this {
-        super.emit(event, arg);
-        return this;
-    }
-
-    on<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this {
-        super.on(event, callback);
-        return this;
-    }
-
-    off<K extends keyof IProcessBaseEvents>(event: K, callback: (...arg: IProcessBaseEvents[K]) => void): this {
-        super.off(event, callback);
-        return this;
-    }
-
-    /*@@
-    get redisMessageHandler(): RedisMessageHandler {
-        return this.#redisMessageHandler as RedisMessageHandler;
-    }
-    */
-}