@nsshunt/stsappframework 3.0.93 → 3.0.95

package/src_new/middleware/serverNetworkMiddleware.ts

@@ -0,0 +1,240 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import chalk from 'chalk'; // Note: Do NOT upgrade beyond 4.1.2 as the ESM version (5.0.0+) breaks this entire codebase
+import { Request, Response, NextFunction } from 'express'
+import { Socket } from 'node:net'
+import { TinyEmitter } from 'tiny-emitter';
+
+import debugModule from 'debug'
+import { STSOptionsBase } from '@nsshunt/stsutils';
+const debug = debugModule(`proc:${process.pid}`);
+
+import { v4 as uuidv4 } from 'uuid';
+import onHeaders  from 'on-headers';
+
+export enum ServerNetworkMiddlewareEventName {
+    UpdateInstrument_SERVER_NET_VAL = 'UpdateInstrument_SERVER_NET_VAL' // request net stats
+}
+
+export interface ISocketRecord {
+    id: string
+    socket: Socket,
+    currentBytesRead: number
+    currentBytesWritten: number
+    lastBytesRead: number
+    lastBytesWritten: number
+    requestBytesRead: number
+    requestBytesWritten: number
+    originalUrl: string
+    eventName: string
+}
+
+export type ServerNetworkMiddlewareEventFunc = (data: ISocketRecord) => void;
+
+export interface IServerNetworkMiddleware {
+    name: string
+    outputDebug: boolean
+}
+
+export class ServerNetworkMiddleware extends STSOptionsBase
+{
+    #tinyEmitter: TinyEmitter = new TinyEmitter();
+    #socketCollection: Record<string, ISocketRecord> = { };
+    #id: string = '';
+    #debug: any;
+
+    constructor(options: IServerNetworkMiddleware) {
+        super(options);
+        if (options.outputDebug) {
+            this.#debug = debug;
+        } else {
+            this.#debug = () => { };
+        }
+    }
+
+    on(eventName: ServerNetworkMiddlewareEventName, callBackFn: ServerNetworkMiddlewareEventFunc) {
+        this.#tinyEmitter.on(eventName, callBackFn);
+    }
+
+    GetSocketRecord = (socket: Socket): ISocketRecord | null => {
+        for (const [, socketRecord] of Object.entries(this.#socketCollection)) {
+            if (socketRecord.socket === socket) {
+                return socketRecord;
+            }
+        }
+        return null;
+    }
+
+    UpdateNetworkStats = (workingSocketRecord: ISocketRecord, eventName: string, req: Request) => {
+        workingSocketRecord.originalUrl = req.originalUrl;
+        workingSocketRecord.eventName = eventName;
+
+        workingSocketRecord.currentBytesRead = req.socket.bytesRead;
+        workingSocketRecord.currentBytesWritten = req.socket.bytesWritten;
+
+        workingSocketRecord.requestBytesRead = workingSocketRecord.currentBytesRead - workingSocketRecord.lastBytesRead;
+        workingSocketRecord.requestBytesWritten = workingSocketRecord.currentBytesWritten - workingSocketRecord.lastBytesWritten;
+
+        //this.#debug(chalk.gray(`totalBytesRead: [${workingSocketRecord.id}] [${workingSocketRecord.originalUrl}] [${eventName}] [${workingSocketRecord.requestBytesRead}]`));
+        //this.#debug(chalk.gray(`totalBytesWritten: [${workingSocketRecord.id}] [${workingSocketRecord.originalUrl}] [${eventName}] [${workingSocketRecord.requestBytesWritten}]`));
+
+        const workingSocketEventRecord = { ...workingSocketRecord };
+        delete (workingSocketEventRecord as any).socket;
+        this.#debug(chalk.gray(`Sending event: [${JSON.stringify(workingSocketEventRecord)}]`));
+        this.#tinyEmitter.emit(ServerNetworkMiddlewareEventName.UpdateInstrument_SERVER_NET_VAL, workingSocketEventRecord);
+
+        workingSocketRecord.lastBytesRead = workingSocketRecord.currentBytesRead;
+        workingSocketRecord.lastBytesWritten = workingSocketRecord.currentBytesWritten;
+    }
+
+    #GetRequestContentSize = (req: Request) => {
+        try {
+            let contentLength = 0;
+            if ((req as any)['_contentLength']) {
+                contentLength = (req as any)['_contentLength'];
+            } else {
+                if (req.headers['content-length']) {
+                    contentLength = parseInt(req.headers['content-length'])
+                }
+            }
+            return contentLength;
+        } catch (error) {
+            this.#debug(chalk.red(`ServerNetworkMiddleware:#GetRequestContentSize(): Error: [${error}]`));
+            return 0;
+        }
+    }
+
+    Middleware = (req: Request, res: Response, next: NextFunction) => {
+        let workingSocketRecord: ISocketRecord | null = null;
+        
+        workingSocketRecord = this.GetSocketRecord(req.socket);
+
+        if (!workingSocketRecord) {
+            this.#id = uuidv4();
+            workingSocketRecord = {
+                id: `${(this.options as IServerNetworkMiddleware).name}_${this.#id.toString()}`,
+                socket: req.socket,
+                currentBytesRead: 0,
+                currentBytesWritten: 0,
+                lastBytesRead: 0,
+                lastBytesWritten: 0,
+                requestBytesRead: 0,
+                requestBytesWritten: 0,
+                originalUrl: req.originalUrl,
+                eventName: '',
+            };
+
+            this.#socketCollection[workingSocketRecord.id] = workingSocketRecord;
+
+            this.#debug(chalk.gray(`Adding new socket to recordset: ID: [${workingSocketRecord.id}], originalUrl: [${workingSocketRecord.originalUrl}]`));
+
+            workingSocketRecord.socket.on('data', () => {
+                const socketRecord = this.GetSocketRecord((workingSocketRecord as ISocketRecord).socket);
+                if (socketRecord) {
+                    this.#debug(chalk.gray(`Socket data event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+                    this.UpdateNetworkStats(socketRecord, 'socket_data', req);
+                } else {
+                    this.#debug(chalk.magenta(`Socket data event: Could not find socket within recordset`));
+                }
+            });
+
+            workingSocketRecord.socket.on('close', () => {
+                const socketRecord = this.GetSocketRecord((workingSocketRecord as ISocketRecord).socket);
+                if (socketRecord) {
+                    this.#debug(chalk.gray(`Socket close event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+                    this.UpdateNetworkStats(socketRecord, 'socket_close', req);
+                    delete this.#socketCollection[socketRecord.id];
+                    this.#debug(chalk.gray(`Socket removed from recordset: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+                } else {
+                    this.#debug(chalk.magenta(`Socket close event: Could not find socket within recordset`));
+                }
+            });
+
+            workingSocketRecord.socket.on('end', () => {
+                const socketRecord = this.GetSocketRecord((workingSocketRecord as ISocketRecord).socket);
+                if (socketRecord) {
+                    this.#debug(chalk.gray(`Socket end event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+                    this.UpdateNetworkStats(socketRecord, 'socket_end', req);
+                } else {
+                    this.#debug(chalk.magenta(`Socket end event: Could not find socket within recordset`));
+                }
+            });
+        }
+
+        // The following gets the payload size from adding _contentLength or content-length to the header size.
+        // From brief observations, this appears to be about 80 bytes short from what is reported by the socket writtenBytes.
+        onHeaders(res, () => {
+            let contentLength = 0;
+            if ((res as any)['_contentLength']) {
+                contentLength = (res as any)['_contentLength'];
+            } else {
+                if (res.hasHeader('content-length')) {
+                    contentLength = parseInt(res.getHeader('content-length') as string);
+                }
+            }
+
+            // Ensure that the client does NOT cache the response
+            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate'); // HTTP 1.1
+            res.setHeader('Pragma', 'no-cache'); // HTTP 1.0
+            res.setHeader('Expires', '0'); // Proxies
+
+            const headerLength = JSON.stringify(res.getHeaders()).length;
+            const totalSize = contentLength + headerLength;
+
+            this.#debug(chalk.white.bgBlue(`contentLength: [${contentLength}], headerLength: [${headerLength}], total Size: [${totalSize}]`));
+        });
+
+        // This event is the one where bytesWritten is generally recorded
+        req.on('end', () => {
+            const socketRecord = this.GetSocketRecord(req.socket);
+            if (socketRecord) {
+                this.#debug(chalk.gray(`Request end event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`))
+                this.UpdateNetworkStats(socketRecord, 'req_end', req);
+            } else {
+                this.#debug(chalk.magenta(`Request end event: Could not find socket within recordset`));
+            }
+        });
+
+        req.on('close', () => {
+            const socketRecord = this.GetSocketRecord(req.socket);
+            if (socketRecord) {
+                this.#debug(chalk.gray(`Request close event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+                this.UpdateNetworkStats(socketRecord, 'req_close', req);
+            } else {
+                this.#debug(chalk.magenta(`Request close event: Could not find socket within recordset`));
+            }
+        });
+
+        /* These methods are also available but from testing they provide no specific value add, i.e. the calculated numbers are always 0.
+        req.on('data', () => {
+            workingSocketRecord = this.GetSocketRecord(req.socket);
+            if (workingSocketRecord) {
+                this.#debug(chalk.gray(`Request close event: ID: [${workingSocketRecord.id}], originalUrl: [${workingSocketRecord.originalUrl}]`));
+                this.UpdateNetworkStats(workingSocketRecord, 'data', req);
+            } else {
+                this.#debug(chalk.magenta(`Request close event: Could not find socket within recordset`));
+            }
+        });
+
+        req.on('readable', () => {
+            workingSocketRecord = this.GetSocketRecord(req.socket);
+            if (workingSocketRecord) {
+                this.#debug(chalk.gray(`Request close event: ID: [${workingSocketRecord.id}], originalUrl: [${workingSocketRecord.originalUrl}]`));
+                this.UpdateNetworkStats(workingSocketRecord, 'readable', req);
+            } else {
+                this.#debug(chalk.magenta(`Request close event: Could not find socket within recordset`));
+            }
+        });
+        */
+
+        const inHeadersLength = JSON.stringify(req.headers).length;
+        const inContentLength = this.#GetRequestContentSize(req);
+        const inTotal = inHeadersLength + inContentLength;
+
+        this.#debug(chalk.white.bgGray(`inHeadersLength: [${inHeadersLength}], inContentLength: [${inContentLength}], inTotal: [${inTotal}]`));
+
+        // This event is the one where bytesRead is generally recorded
+        this.UpdateNetworkStats(workingSocketRecord, 'middleware', req);
+
+        next();
+    }
+}

package/src_new/network.ts

@@ -0,0 +1,36 @@
+import os from 'os'
+
+export type NetworkInterfaces = Record<string, string[]>
+
+export function GetNetworkInterfaces(): NetworkInterfaces {
+    const nets = os.networkInterfaces();
+    const results: NetworkInterfaces = { };
+    for (const name of Object.keys(nets)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const net of nets[name] as any) {
+            // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
+            if (net.family === 'IPv4' && !net.internal) {
+                if (!results[name]) {
+                    results[name] = [];
+                }
+                results[name].push(net.address);
+            }
+        }
+    }
+    return results;
+}
+
+export function GetFirstNetworkInterface(): string | null {
+    const nics: NetworkInterfaces = GetNetworkInterfaces();
+    let hostaddr = null;
+    for (const nic in nics)
+    {
+        const val: string[] = nics[nic];
+        if (val.length > 0)
+        {
+            hostaddr = val[0];
+            break;
+        }
+    }
+    return hostaddr;
+}

package/src_new/processbase.ts

@@ -0,0 +1,413 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import pidusage from 'pidusage'
+import { memoryUsage, exit } from 'process'
+import path from 'node:path';
+import cluster from 'node:cluster'
+import colors from 'colors'
+import si from 'systeminformation' // https://systeminformation.io/
+import { GetFirstNetworkInterface } from './network'
+
+import chalk from 'chalk';
+
+import debugModule from 'debug'
+const debug = debugModule(`proc:${process.pid}:processBase`);
+
+import { Gauge, InstrumentBaseTelemetry, InstrumentGaugeTelemetry, InstrumentObjectTelemetry, InstrumentLogTelemetry } from '@nsshunt/stsinstrumentation'
+
+import { PGAccessLayer, PGPoolManager, PGPoolManagerEventName } from '@nsshunt/stsdatamanagement'
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import { ProcessOptions, STSServerType } from './processoptions'
+import { STSOptionsBase, JSONObject } from '@nsshunt/stsutils'
+import { StatusCodes } from 'http-status-codes'
+
+import { PublishInstrumentControllerV2, IPublishInstrumentControllerOptionsV2, InstrumentDefinitions, 
+    IWorkerFactory, TransportType, IPublishTransportRESTServerOptions, 
+    CreateServiceProcessContext, PublishTransportRESTServerV2, IPublisherTransport } from '@nsshunt/stspublisherserver'
+
+//import { PublishCollectorInProcessWorkerFactory } from './processcollectorinprocessworker'
+
+import { Worker } from 'worker_threads';
+
+import os from 'os';
+
+import { IProcessBase, ISocketIoServerHelper, logFunction } from './commonTypes'
+import { TimeSeriesDuplicatePolicies } from 'redis';
+
+import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketio-client'
+
+//import ProcessBrokerWorker from './processbrokerworker.js?worker'
+
+import { PublishTransportDirect } from './publishertransports/publishTransportDirect'
+
+export abstract class ProcessBase extends STSOptionsBase implements IProcessBase 
+{
+    #instrumentController: PublishInstrumentControllerV2 | null = null;
+    #systemInformationInterval: NodeJS.Timer | null = null;
+    #socketIoServerHelper: ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null = null;
+    #accessLayer: PGAccessLayer | null = null;
+    #poolManager: PGPoolManager | null = null;
+    #logEx: logFunction | null = null;
+
+    constructor(options: ProcessOptions)
+    {
+        super(options);
+
+        if (options.serviceName) {
+            this.options.serviceProcessContext = CreateServiceProcessContext(options.serviceName, options.serviceVersion, options.serviceInstanceId,
+                os.hostname(), process.pid, options.isMaster ? process.pid : process.ppid)
+        }
+    }
+
+    override get options(): ProcessOptions {
+        return super.options as ProcessOptions;
+    }
+
+    get shuttingDown(): boolean {
+        return false;
+    }
+    
+    #log(appName: any): logFunction {
+        return (msg) =>
+        {
+            let prefix = '';
+            let col = null;
+    
+            if (cluster.isPrimary)
+            {
+                prefix = 'M';
+                col = colors.bold.cyan; // chalk.bold.cyan;
+            } else {
+                prefix = 'W';
+                col = colors.green; //  chalk.green;
+            }
+            const msgEx = col(`${prefix}(${process.pid}) [${appName}]: ${msg}`);
+            debug(msgEx);
+        
+            this.UpdateInstrument(Gauge.LOGGER, {
+                LogMessage: msgEx
+            } as InstrumentLogTelemetry);
+        };
+    }
+
+    #GetRootFolder = (): string => {
+        const mainpath = require.resolve('@nsshunt/stsutils');
+        const anotherDir = path.dirname(mainpath);
+        const sSplit = anotherDir.split('/')
+        const result = sSplit.slice(0, -5) // Remove the last 4 path elements, this will be 'node_modules/@nsshunt/stsutils/dist'
+        return result.join('/');
+    }
+    
+    #ServiceCollectorWorkerFactory: IWorkerFactory = {
+        createWorker: (): Worker => {
+            const fileName = this.#GetRootFolder() + '/stsappframework/dist/processcollectorworker.js';
+
+            //@@ check for copy env like
+            // const envCopy = { ...process.env };
+            const publishCollectorWebWorker = new Worker(fileName, {
+                workerData: 500 // ??
+                // ,env: envCopy
+            });
+
+            publishCollectorWebWorker.unref();
+
+            return publishCollectorWebWorker;
+        },
+        /*
+        createInProcessWorker: (): PublishCollectorWorker => {
+            return PublishCollectorInProcessWorkerFactory();
+        },
+        */
+        options: {
+            transportType: TransportType.RESTAPI,
+            url: `${goptions.imendpoint}:${goptions.import}${goptions.imapiroot}/publishmessage`,
+            publishdebug: goptions.publishdebug,
+            // 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)
+            }
+        } as IPublishTransportRESTServerOptions
+    }
+
+    #ServiceBrokerWorkerFactory: IWorkerFactory = {
+        createWorker: (): Worker => {
+            const fileName = this.#GetRootFolder() + '/stsappframework/dist/processbrokerworker.js';
+
+            //@@ check for copy env like
+            // const envCopy = { ...process.env };
+            const publishBrokerWebWorker = new Worker(fileName, {
+                //workerData: this.options.serviceProcessContext 
+                // ,env: envCopy
+            });
+
+            publishBrokerWebWorker.unref();
+
+            return publishBrokerWebWorker;
+        }
+        /*
+        createInProcessWorker: (): PublishBrokerWorker => {
+            return PublishBrokerInProcessWorkerFactory();
+        },
+        */
+    }
+
+    SetupInstrumentation()
+    {
+        if (!this.options.serviceProcessContext) {
+            return;
+        }
+
+        let publisherTransport: IPublisherTransport
+
+        if (goptions.observabilityPublishMode.localeCompare('PROXY') === 0) {
+            const publishTransportOptions: IPublishTransportRESTServerOptions = {
+                transportType: TransportType.RESTAPI,
+                url: `${goptions.imendpoint}:${goptions.import}${goptions.imapiroot}/publishmessage`,
+                publishdebug: goptions.publishdebug,
+                // 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)
+                }
+            };
+            publisherTransport = new PublishTransportRESTServerV2(publishTransportOptions);
+        } else {
+            publisherTransport = new PublishTransportDirect();   
+        }
+
+        const instrumentControllerOptions: IPublishInstrumentControllerOptionsV2 = {
+            processContext: this.options.serviceProcessContext,
+            //payloadType: InstrumentPayloadType.service,
+            consoleLogging: this.options.consoleLogging,
+            instrumentLogging: this.options.instrumentLogging,
+            httpServer: (this.options.serverType === STSServerType.EXPRESS || this.options.serverType === STSServerType.EXPRESS_TLS),
+            instrumentationObservationInterval: this.options.instrumentationObservationInterval,
+            instrumentationTimeWindow: this.options.instrumentationTimeWindow,
+            instrumentDefinitions: this.GetAdditionalInstruments(),
+            publisherTransport
+        }
+
+        this.#instrumentController = new PublishInstrumentControllerV2(instrumentControllerOptions);
+    }
+
+    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
+        this.#systemInformationInterval = setInterval(() => {
+            pidusage(process.pid, (err, stats) => {
+
+                if (this.#instrumentController) {
+                    this.#instrumentController.UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
+                        val: stats.cpu
+                    } 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();
+
+        }, goptions.systemInformationInterval).unref();
+		
+        this.#logEx = this.#log(this.options.serviceName);
+
+        if (this.options.useDatabase) {
+            // Get the accessLayer to force DB connection test
+            this.accessLayer;
+        }
+    }
+
+    UpdateInstrument = (instrumentName: Gauge, telemetry: InstrumentBaseTelemetry) => {
+        if (this.#instrumentController) {
+            this.#instrumentController.UpdateInstrument(instrumentName, telemetry);
+        }
+    }
+
+    get InstrumentController(): PublishInstrumentControllerV2 | null {
+        return this.#instrumentController;
+    }
+
+    LogEx = (message: any) => {
+        if (this.#logEx) {
+            this.#logEx(message);
+        } else {
+            console.log('')
+            console.log('************* Attempt to log before _logex set ***************')
+            console.log(message)
+            console.log('')
+        }
+    }
+
+    InstrumentExists(instrumentName: Gauge): boolean
+    {
+        if (this.#instrumentController) {
+            return this.#instrumentController.InstrumentExists(instrumentName);
+        }
+        return false;
+    }
+
+    ProcessTerminate = async () =>
+    {
+        if (this.#systemInformationInterval) {
+            clearInterval(this.#systemInformationInterval);
+        }
+        this.#systemInformationInterval = null;
+    }
+
+    /**
+	 * 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() {
+        if (this.#accessLayer && this.#poolManager) {
+            this.#poolManager.off(PGPoolManagerEventName.UpdateInstruments, this.#UpdatePGPoolManagerInstrument)
+            await this.#accessLayer.enddatabase();
+        }
+    }
+
+    get accessLayer(): PGAccessLayer | null
+    {
+        if (this.options.useDatabase) {
+            if (this.#accessLayer === null) {
+                this.#poolManager = new PGPoolManager();
+                this.#accessLayer = new PGAccessLayer(this.#poolManager);
+                (async () => {
+                    try {
+                        const retVal = await (this.accessLayer as PGAccessLayer).getResourceCount();
+                        if (retVal.status !== StatusCodes.OK) {
+                            this.LogEx(chalk.red(`Unable to get resources from the database. Is the database running? [${JSON.stringify(retVal)}]`));
+                            exit(1);
+                        } else {
+                            this.LogEx(chalk.green(`Database connection successful. Resources: [${retVal.detail.count}]`));
+                        }
+                    } catch (error) {
+                        this.LogEx(chalk.red(`Unable to get resources from the database. Is the database running? Error: [${error}]`));
+                        exit(1);
+                    }
+                })();
+                this.#poolManager.on(PGPoolManagerEventName.UpdateInstruments, this.#UpdatePGPoolManagerInstrument)
+            }
+            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.LogEx(`Host Address: ${hostaddr}`);
+        } else {
+            this.LogEx(`Unknown Host Address.`);
+        }
+        this.LogEx(`Server starting with ${numCPUs} Cores/Threads`);
+
+        this.LogEx(`Hostname: ${hostname}`);
+        this.LogEx(`System: ${JSON.stringify(sysinfo.system)}`);
+        this.LogEx(`OS Info: ${JSON.stringify(sysinfo.osInfo)}`);
+        this.LogEx(`CPU: ${JSON.stringify(sysinfo.cpu)}`);
+        this.LogEx(`Memory: ${JSON.stringify(sysinfo.mem)}`);
+    }
+
+    GetSignalColour = (signal: any) => {
+        let msgcolor = null;
+        if (signal === 'SIGINT') {
+            msgcolor = chalk.yellow;
+        } else {
+            msgcolor = chalk.red;
+        }
+        return msgcolor;
+    };
+}