@nsshunt/stsappframework 3.2.1 → 3.2.2

package/src/process/masterprocessbase.ts

@@ -1,674 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import fs from "node:fs"
-import si from 'systeminformation' // https://systeminformation.io/
-
-import axios from 'axios';
-
-import cluster, { Worker, Address } from 'node:cluster'
-
-import chalk from 'chalk';
-
-import express from 'express'
-
-import { setupPrimary } from '@socket.io/cluster-adapter'
-import { createServer as createServerHttps } from 'node:https'
-import { createServer } from 'node:http'
-import { AggregatorRegistry } from 'prom-client'
-
-import { goptions, STSAxiosConfig, AgentManager } from '@nsshunt/stsconfig'
-
-import { Gauge, GaugeTypes, InstrumentGaugeTelemetry, InstrumentGaugeOptions, InstrumentHistogramTelemetry } from '@nsshunt/stsobservability'
-
-import { ProcessBase } from './processbase';
-import { IMasterProcessBase, ProcessOptions } from './../commonTypes';
-
-import { InstrumentDefinitions } from '@nsshunt/stsobservability'
-import { IPCMessagePayload, IPCMessageCommand } from './../commonTypes'
-
-import { STSTransportLoggerWinston } from './../logger/stsTransportLoggerWinston'
-
-import { Sleep } from '@nsshunt/stsutils'
-
-//import { GetFirstNetworkInterface } from './network';
-
-export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
-{
-    //static WORKER_MESSAGE_EVENT = 'sts_worker_message_event';
-    #masterProcessExitTime = goptions.masterProcessExitTime;
-    #childProcessExitTime = goptions.childProcessExitTime;
-    #siValueObject = {
-        currentLoad: 'currentLoad'
-    }
-    #httpServer: any = null; // Prometheus cluster server. See https://github.com/siimon/prom-client/blob/master/example/cluster.js
-    #metricsServer: any= null;
-    #aggregatorRegistry: any = null;
-    #checkLatency: NodeJS.Timeout | null = null;
-    #killWorkers: Record<string, string> = { };
-    #workers = 1; // Start at 1 becuase of main thread
-    #shuttingDown = false;
-    #agentManager: AgentManager;
-
-    constructor(options: ProcessOptions)
-    {
-        super(options);
-
-        this.#agentManager = new AgentManager({
-            agentOptions: {
-                keepAlive: false, // Use basic defaults. This agent will not use keep-alive.
-                maxFreeSockets: goptions.maxFreeSockets,
-                maxSockets: goptions.maxSockets,
-                maxTotalSockets: goptions.maxTotalSockets,
-                timeout: goptions.timeout,
-                rejectUnauthorized: goptions.isProduction // Allows self-signed certificates if non-production
-            }
-        });
-    }
-
-    #LogErrorMessage(message: any) {
-        this.options.logger.error(message);
-    }
-
-    #LogDebugMessage(message: any) {
-        this.options.logger.debug(message);
-    }
-
-    override CollectAdditionalTelemetry(): void {
-        si.get(this.#siValueObject).then(data => {
-            this.UpdateInstrument(Gauge.CPU_SYSTEM_LOAD_GAUGE, {
-                val: data.currentLoad.currentLoad
-            } as InstrumentGaugeTelemetry);
-        });
-    }
-
-    override GetAdditionalInstruments(): InstrumentDefinitions {
-        return [
-            [ Gauge.CPU_SYSTEM_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
-                interval: goptions.instrumentationObservationInterval, 
-                sampleSize: goptions.instrumentationTimeWindow
-            } as InstrumentGaugeOptions]
-        ]
-    }
-
-    /**
-	 * Note: msg removed from signature but will be passed at run-time.
-	 * @param {*} msg 
-	 */
-     
-    WorkerMessageEvent(workerId: number, msg: any) {
-        return null;
-    }
-
-     
-    #WorkerMessageEvent(workerId: number, msg: any) {
-        if (msg.command) {
-            this.WorkerMessageEvent(workerId, msg);
-        }
-    }
-
-    #InitCluster = () => {
-        cluster.on('listening', (worker: Worker, address: Address) => {
-            this.emit('clusterListening', worker, address);
-            let allListening = true;
-            for (const worker of Object.values(cluster.workers as NodeJS.Dict<Worker>)) {
-                if (worker?.isConnected) {
-                    allListening = false;
-                    break;
-                }
-            }
-            if (allListening) {
-                this.LogInfoMessage(`Service instance started.`);
-                this.emit('allListening');
-            }
-        });
-    };
-
-    // https://github.com/siimon/prom-client/blob/master/example/cluster.js
-    #SetupPrometheusForMaster = () => {
-        this.#metricsServer = express();
-        this.#aggregatorRegistry = new AggregatorRegistry();
-
-        switch (goptions.STSServerType) {
-        case 'EXPRESS_TLS' : {
-            const options = {
-                key: fs.readFileSync(this.options.httpsServerKeyPath),
-                cert: fs.readFileSync(this.options.httpsServerCertificatePath)
-            };
-            this.#httpServer = createServerHttps(options, this.#metricsServer);
-        }
-            break;
-        case 'EXPRESS' : {
-            this.#httpServer = createServer(this.#metricsServer);
-        }
-        }
-        //this.#httpServer.maxConnections = 50;
-
-        this.#metricsServer.get('/cluster_metrics', async (req: any, res: any) => {
-            try {
-                const metrics = await this.#aggregatorRegistry.clusterMetrics();
-                res.set('Content-Type', this.#aggregatorRegistry.contentType);
-                res.send(metrics);
-            } catch (ex: any) {
-                res.statusCode = 500;
-                res.send(ex.message);
-            }
-        });
-
-        //@@@ options wrong
-
-        try {
-            // https://stackoverflow.com/questions/21342828/node-express-unix-domain-socket-permissions
-            //@@httpServer.listen('/tmp/stsrest01.sock').on('listening', () =>
-            //@@httpServer.listen('/var/run/sts/stsrest01.sock').on('listening', () =>
-            //@@httpServer.listen('/var/lib/sts/stsrest01.sock').on('listening', () =>
-            this.#httpServer.listen(this.options.prometheusClusterPort, () => { 
-                //@@chmodSync(this.options.port, 511);
-            }).on('listening', () =>
-            {
-                this.emit('prometheusScrapesListening', `${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`,
-                    this.options.endpoint,
-                    this.options.prometheusClusterPort);
-                this.LogInfoMessage(`Prometheus scrapes ready and live on ${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`);
-            });
-        } catch (error)
-        {
-            this.#LogErrorMessage(error);
-            throw error;
-        }
-    }
-
-    #CheckLatency = async () => {
-        const start = process.hrtime();
-        await this.#GetLatency();
-        this.#LatencyRequestCompleted(start);
-    }
-
-     
-    #GetLatency = async (): Promise<any> => {
-        let retVal: any = null;
-        // We use port rather than hostport becuase this test going outside the service and comes back in as a regular client
-        const url = `${this.options.endpoint}:${this.options.port}${this.options.apiRoot}/latency`;
-        try {
-            retVal = await axios(new STSAxiosConfig(url, 'get')
-                .withDefaultHeaders()
-                .withAgentManager(this.#agentManager).config);
-            if (retVal.status !== 200) {
-                this.#LogDebugMessage(chalk.magenta(`Error (MasterProcessBase:#GetLatency): Invalid response from server: [${retVal.status}]`));
-                return null;
-            }
-            return retVal.data.detail;
-        } catch (error: any) {
-            this.#LogDebugMessage(chalk.red(`Error (MasterProcessBase:#GetLatency:catch): [${error}]`));
-            this.#LogDebugMessage(chalk.red(`  url: [${url}]`));
-            if (error.response && error.response.data) {
-                this.#LogDebugMessage(chalk.red(`  Details: [${JSON.stringify(error.response.data)}]`));
-            }
-        }
-    }
-
-    #LatencyRequestCompleted = (start: any) => {
-        // Update request duration histo data
-        let timeInMs = 0;
-        const end = process.hrtime(start);
-        timeInMs = (end[0]* 1000000000 + end[1]) / 1000000;
-        timeInMs = parseFloat(timeInMs.toFixed(4));
-		
-        this.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
-            val: timeInMs
-        } as InstrumentHistogramTelemetry);
-
-        this.UpdateInstrument(Gauge.LATENCY_GAUGE, {
-            val: timeInMs
-        } as InstrumentGaugeTelemetry);
-    };
-
-    SetupServer = async () => {
-        this.SetupInstrumentation();
-        setTimeout(() => {
-            this.SetupServerEx();
-        }, 100);
-    }
-
-    #_KillWorker = (id: string, signal: NodeJS.Signals, killProcess: boolean): boolean => {
-        try {
-            if (cluster.workers && cluster.workers[id]) {
-                const worker = cluster.workers[id] as Worker;
-                if (worker.process) {
-                    this.LogInfoMessage(chalk.grey(`Sending terminate message `) + chalk.yellow(`(initiated by ${signal})`) + chalk.grey(` for worker PID: ${worker.process.pid}`));
-                    const command: string = (killProcess ? 'TerminateAndKill' : 'Terminate');
-                    try {
-                        worker.send( { command } );
-                        //worker.process.send( { command } );
-                    } catch (error) {
-                        this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker() (1): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
-                        return false;
-                    }
-                    return true;
-                } else {
-                    this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker(): Could not kill worker with id: [${id}]. The process does not exists`));
-                    return false;
-                }
-            } else {
-                this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker(): Could not kill worker with id: [${id}]. Worker does not exist within workers collection`));
-                return false;
-            }
-        } catch (error) {
-            this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker() (2): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
-            return false;
-        }
-    }
-
-     
-    KillWorker = (id: string, signal: NodeJS.Signals = "SIGTERM", options: any, killProcess: boolean, allowKillAll: boolean): boolean => {
-        try {
-            if (allowKillAll || Object.keys(cluster.workers as NodeJS.Dict<Worker>).length > 1) {
-                if (id.localeCompare('0') === 0) {
-                    const keys = Object.keys(cluster.workers as NodeJS.Dict<Worker>);
-                    for (let i=keys.length-1; i > 0; i--) {
-                        // Kill the last one added (assumed node keeps them in order)
-                        id = keys[i];
-                        if (!this.#killWorkers[id]) {
-                            this.#killWorkers[id] = id;
-                            // Allow some time for the worker to be terminated before clean-up of the killWorkers array
-                            setTimeout(() => {
-                                delete this.#killWorkers[id];
-                            }, 2000).unref(); //@@
-                            return this.#_KillWorker(id, signal, killProcess);
-                        }
-                    }
-                    return false;
-                } else {
-                    return this.#_KillWorker(id, signal, killProcess);
-                }
-            } else {
-                this.LogInfoMessage(chalk.yellow(`MasterProcessBase:KillWorker(): Not allowed to kill the last worker process.`));
-                return false;
-            }
-        } catch (error) {
-            this.LogInfoMessage(chalk.red(`MasterProcessBase:KillWorker(): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
-            return false;
-        }
-    }
-
-    KillWorkers = (signal: NodeJS.Signals, keepOne?: boolean): void => {
-        const logPrefix = `MasterProcessBase:KillWorkers():${process.pid}:`;
-        try {
-            this.LogInfoMessage(`${logPrefix} Killing Workers.`);
-            const keepOneAlive = (keepOne ? keepOne : false);
-            let skippedFirst = false;
-            const sortedIdList: number[] = [ ];
-            for (const id in cluster.workers) {
-                sortedIdList.push(parseInt(id));
-            }
-            sortedIdList.sort().forEach((id) => {
-                if (keepOneAlive && !skippedFirst) {
-                    skippedFirst = true;
-                } else {
-                    this.KillWorker(id.toString(), signal, null, false, true);
-                }
-            });
-        } catch (error) {
-            this.LogInfoMessage(chalk.red(`${logPrefix} signal: [${signal}], keepOne: [${keepOne}], error: [${error}]`));
-        }
-    }
-
-    #UpdateWorkersInstrument = (): void => {
-        setTimeout(() => {
-            this.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
-                val: this.#workers
-            } as InstrumentGaugeTelemetry);
-        }, 2000);
-    }
-
-    IncWorkers = (): void => {
-        this.#workers++;
-        this.#LogDebugMessage(`  Inc Workers. Total thread count: [${this.#workers}]`);
-        this.#UpdateWorkersInstrument();
-    }
-
-    DecWorkers = (): void => {
-        this.#workers--;
-        this.#LogDebugMessage(`  Dec Workers. Total thread count: [${this.#workers}]`);
-        this.#UpdateWorkersInstrument();
-    }
-
-     
-    AddWorker = (options: any): number => {
-        const workerId: number = this.#SpawnWorker(options);
-        this.#LogDebugMessage(chalk.yellow(`  Spawned worker with id: [${workerId}]`));
-        if (options) {
-            this.#LogDebugMessage(chalk.yellow(`  Options: [${JSON.stringify(options)}]`));
-        }
-        return workerId;
-    }
-
-    async ProcessIPCCommand(iPCMessagePayload: IPCMessagePayload): Promise<IPCMessagePayload> {
-        return this.#processIPCCommand(iPCMessagePayload);
-    }
-
-    #processIPCCommand = async (iPCMessagePayload: IPCMessagePayload): Promise<IPCMessagePayload> => {
-        this.#LogDebugMessage(chalk.yellow(`  Processing message command: [${iPCMessagePayload.command}]`));
-        switch (iPCMessagePayload.command) {
-        case IPCMessageCommand.AddWorker : {
-            const workerId = this.AddWorker(iPCMessagePayload.requestDetail?.options);
-            iPCMessagePayload.responseDetail = {
-                workerId
-            }
-            return iPCMessagePayload;
-        }
-        case IPCMessageCommand.DeleteWorker : {
-            const workerId = iPCMessagePayload.requestDetail?.workerId;
-            const workerKilled = this.KillWorker(workerId, "SIGTERM", iPCMessagePayload.requestDetail?.options, true, false);
-            this.#LogDebugMessage(chalk.yellow(`  Killed worker with id: [${workerId}]`));
-            iPCMessagePayload.responseDetail = {
-                workerId,
-                workerKilled
-            }
-            return iPCMessagePayload;
-        }
-        case IPCMessageCommand.GetConfig : {
-            const safeOptions = { ...this.options };
-            delete (safeOptions as any).logger
-            delete (safeOptions as any).publisherLogger
-            delete (safeOptions as any).expressServerRouteFactory
-            //this.#LogDebugMessage(chalk.yellow(`  Safe options: [${JSON.stringify(safeOptions)}]`));
-            iPCMessagePayload.responseDetail = {
-                safeOptions
-            }
-            return iPCMessagePayload;
-        }
-        default : {
-            const errorMessage = `Could not process command: [${iPCMessagePayload.command}].`;
-            this.#LogDebugMessage(chalk.red(`  ${errorMessage}`));
-            throw new Error(errorMessage);
-        }
-        }
-    }
-
-     
-    #SpawnWorker = (spawnWorkerOptions?: any): number => {
-        const workerEnv: any = { };
-
-        const tempOptions = { ...this.options };
-
-        // Remove the assigned loggers (this will need to be re-created in the worker thread)
-        delete (tempOptions as any).logger;
-        delete (tempOptions as any).publisherLogger;
-
-        workerEnv['STS_GSD_SII'] = JSON.stringify(tempOptions);
-        if (spawnWorkerOptions) {
-            workerEnv['STS_GSD_OPTIONS'] = JSON.stringify(spawnWorkerOptions);
-        }
-
-        // https://nodejs.org/api/cluster.html#clustersetupprimarysettings
-        if (this.options.workerExec) {
-            cluster.setupPrimary({
-                exec: this.options.workerExec,
-                silent: true,
-            });
-        }
-
-        const worker = cluster.fork(workerEnv);
-        this.IncWorkers();
-
-        worker.on('exit', (code, signal) => {
-            this.emit('workerExit', code, signal);
-            if (signal) {
-                this.LogInfoMessage(`Worker: ${worker.process.pid} was killed by signal: ${signal}`);
-            } else if (code !== 0) {
-                this.LogInfoMessage(`Worker: ${worker.process.pid} exited with error code: ${code}`);
-            } else {
-                this.LogInfoMessage(`Worker: ${worker.process.pid} exited successfully, code: ${code}, signal: ${signal}`);
-            }
-        });
-
-        worker.on('message', async (payload) => {
-            this.emit('workerMessage', worker.id, payload);
-            // Only handle request/response message types here ...
-            if (payload.requestResponse) {
-                const iPCMessagePayload: IPCMessagePayload = payload as IPCMessagePayload;
-                //this.#LogDebugMessage(chalk.yellow(`Received message with id: [${iPCMessagePayload.id}] from worker: [${worker.process.pid}]. Details: [${JSON.stringify(iPCMessagePayload)}]`));
-                const response: IPCMessagePayload = await this.ProcessIPCCommand(iPCMessagePayload);
-                //this.#LogDebugMessage(chalk.green(`Sending response message with id: [${iPCMessagePayload.id}] to worker: [${worker.process.pid}]. Details: [${JSON.stringify(response)}]`));
-                worker.send(response);
-            } else {
-                this.#WorkerMessageEvent(worker.id, payload);
-            }
-        });
-
-        worker.on('error', (error) => {
-            this.emit('workerError', error);
-            const message = chalk.red(`#SpawnWorker():worker.on('error'): Error: [${error}]`);
-            this.LogErrorMessage(message);
-        });
-
-        this.emit('workerAdded', worker.id);
-
-        return worker.id;
-    };
-
-    MasterStarted(): void { // eslint-disable @typescript-eslint/no-empty-function
-        const transport = new STSTransportLoggerWinston({
-            stsApp: this
-        });
-        setTimeout(() => {
-            (this.options.logger as any).add(transport);
-        }, 0);
-    }
-
-    override get shuttingDown(): boolean {
-        return this.#shuttingDown;
-    }
-
-    SetupServerEx = async () =>
-    {
-        this.ProcessStartup();
-
-        this.LogInfoMessage(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
-
-        this.LogSystemTelemetry();
-
-        // socket.io
-        // setup connections between the workers
-        if (this.options.wssServer === true) {
-            if (this.options.useSocketIoRedisAdaptor) {
-                this.LogInfoMessage(`Using Redis for socket.io cluster management (master)`);
-            } else {
-                this.LogInfoMessage(`Using nodejs cluster mode for socket.io cluster management`);
-                setupPrimary();
-            }
-        }
-
-        if (this.options.prometheusSupport === true) {
-            this.#SetupPrometheusForMaster();
-        }
-
-        const numCPUs = await this.GetNumCPUs();
-        for (let i=0; i < numCPUs; i++) {
-            this.#SpawnWorker();
-        }
-
-        this.#InitCluster();
-
-        cluster.on('listening', (worker, address) => {
-            this.emit('clusterListening', worker, address);
-            this.LogInfoMessage(`Worker process ${worker.process.pid} is listening at address: ${JSON.stringify(address)}`);
-        });
-
-        //Setting up lifecycle event listeners for worker processes
-        cluster.on('online', worker => {
-            this.emit('clusterOnline', worker);
-            this.LogInfoMessage(`Worker process ${worker.process.pid} is online`);
-        });
-
-        cluster.on('exit', (worker, code, signal) => {
-            this.emit('clusterExit', worker, code, signal);
-            if ((code !== null && code === 0) || (signal === 'SIGINT')) {
-                this.LogInfoMessage(chalk.green(`Process ${worker.process.pid} terminated gracefully with code: ${code}, signal: ${signal}`));
-                this.DecWorkers();
-            } else if ((code !== null && code === 15) || (signal === 'SIGTERM')) {
-                this.DecWorkers();
-                this.LogInfoMessage(chalk.red(`Process ${worker.process.pid} terminated with code: ${code}, signal: ${signal}`));
-            } else {
-                this.DecWorkers();
-                this.LogInfoMessage(chalk.red(`worker ${worker.process.pid} died`));
-                this.LogInfoMessage(chalk.red(`code: ${code}`));
-                this.LogInfoMessage(chalk.red(`signal: ${signal}`));
-                this.LogInfoMessage(chalk.red('process terminated in an error state'));
-                if (goptions.respawnOnFail === true) {
-                    this.LogInfoMessage(chalk.magenta(`Attemping to respawn worker`));
-                    this.#SpawnWorker();
-                }
-            }
-        });
-
-        const TerminateLatency = () => {
-            if (this.#checkLatency) {
-                clearInterval(this.#checkLatency);
-                this.#checkLatency = null;
-            }
-        }
-
-        const TerminateHTTPServer = async (): Promise<void> => {
-            if (this.#httpServer !== null) {
-                const logPrefix = `ServerProcessBase:TerminateHTTPServer():${process.pid}:`;
-                this.LogInfoMessage(`${logPrefix} Closing httpServer.`);
-                await this.#httpServer.close();
-                this.#httpServer = null;
-            }
-        }
-
-        // Terminate in order;
-        // forked worker threads (send signal)
-        // De-Register service
-        // systeminformation observers
-        // instrument timers (gauge etc.)
-        // publisher
-        // terminate UI (if loaded)
-        const Terminate = async (signal: any): Promise<void> => {
-            const logPrefix = `MasterProcessBase:Terminate():${process.pid}:`;
-            if (this.#shuttingDown === false) {
-                this.#shuttingDown = true;
-
-                if (signal) {
-                    this.LogInfoMessage(this.GetSignalColour(signal)(`${logPrefix} Received signal: ${signal}`));
-                } else {
-                    this.LogInfoMessage(this.GetSignalColour(null)(`${logPrefix} Received Terminate without signal.`));
-                }
-
-                TerminateLatency();
-
-                await this.ProcessTerminate();
-
-                this.TerminateUIController();
-    
-                this.LogInfoMessage(`${logPrefix} De-Registering service.`);
-                //@@ De-register here ...
-
-                await TerminateHTTPServer();
-
-                this.KillWorkers(signal);
-
-                await this.TerminateDatabase();
-
-                this.TerminateInstrumentController();
-
-                await Sleep(1000);
-
-                this.ProcessExit(this.#childProcessExitTime + this.#masterProcessExitTime);
-
-            } else {
-                this.LogInfoMessage(`${logPrefix} Process already terminating.`);
-            }
-        }
-
-        process.on('SIGINT', async () => {
-            this.emit('processSigint');
-            await Terminate('SIGINT');
-        });
-
-        process.on('SIGTERM', async () => {
-            this.emit('processSigterm');
-            await Terminate('SIGTERM');
-        });
-
-        process.on('exit', (code) => {
-            this.emit('processExit', code);
-            if (code === 0) {
-                this.LogInfoMessage(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
-            } else {
-                this.LogInfoMessage(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
-            }
-        });
-
-        if (this.options.useLatency) {
-            this.#checkLatency = setInterval(() => {
-                this.#CheckLatency();
-            }, 1000).unref();
-        }
-
-        this.MasterStarted();
-
-        this.LogInfoMessage(chalk.green(`Master process:${process.pid} started`));
-    }
-
-    BroadcastDataToWorkers = (command: any, data: any) => {
-        try {
-            for (const id in cluster.workers) {
-                try {
-                    //@@this.LogInfoMessage(chalk.gray(`Sending message to worker PID: ${cluster.workers[id].process.pid}`));
-                    (cluster.workers[id] as Worker).process.send( { command: command, data: data } );
-                } catch (error) {
-                    //@@this.LogInfoMessage(error);
-                }
-            }
-        } catch (error) {
-            //@@this.LogInfoMessage(error);
-        }
-    }
-
-    /*
-    #GetSystemInformation = async (): Promise<JSONObject> => {
-        // https://systeminformation.io/
-        const valueObject = {
-            system: '*',
-            osInfo: '*',
-            cpu: '*',
-            mem: '*',
-            dockerInfo: '*',
-            //dockerImages: '*',
-            dockerContainers: '*',
-        }
-    
-        const sysinfo = await si.get(valueObject);
-        const numCPUs = await this.GetNumCPUs();
-        const hostname = sysinfo.osInfo.hostname;
-    
-        const hostaddr = GetFirstNetworkInterface();
-    
-        const promArray: Promise<any>[] = [ ];
-    
-        sysinfo.dockerContainers.forEach((dc: { id: string; }) => {
-            const dcs = promArray.push(si.dockerContainerStats(dc.id));
-            console.log(dcs);
-        });
-        const dockerContainerStats = await Promise.all(promArray);
-    
-        const sysInfo = {
-            serviceProcessContext: this.options.serviceProcessContext,
-            hostname,
-            numCPUs,
-            hostaddr,
-            system: sysinfo.system,
-            osInfo: sysinfo.osInfo,
-            cpu: sysinfo.cpu,
-            mem: sysinfo.mem,
-            dockerInfo: sysinfo.dockerInfo,
-            //dockerImages: sysinfo.dockerImages,
-            dockerContainers: sysinfo.dockerContainers,
-            dockerContainerStats
-        }
-
-        return sysInfo;
-    }
-    */
-}