@nsshunt/stsappframework 3.1.17 → 3.1.19

package/src/masterprocessbase.ts

@@ -29,6 +29,7 @@ import { InstrumentDefinitions } from '@nsshunt/stspublisherserver'
 import { IPCMessagePayload, IPCMessageCommand } from './commonTypes'
 
 import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
+import { ISTSLogger } from "@nsshunt/stsutils";
 
 export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 {
@@ -99,7 +100,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         }
     }
 
-    #InitCluster = (LogEx: any) =>
+    #InitCluster = () =>
     {
         cluster.on('listening', () => {
             let allListening = true;
@@ -111,13 +112,13 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
             }
 
             if (allListening) {
-                LogEx(`Service instance started.`);
+                this.LogInfoMessage(`Service instance started.`);
             }
         });
     };
 
     // https://github.com/siimon/prom-client/blob/master/example/cluster.js
-    #SetupPrometheusForMaster = (LogEx: any) => {
+    #SetupPrometheusForMaster = () => {
         this.#metricsServer = express();
         this.#aggregatorRegistry = new AggregatorRegistry();
 
@@ -158,7 +159,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                 //@@chmodSync(this.options.port, 511);
             }).on('listening', () =>
             {
-                LogEx(`Prometheus scrapes ready and live on ${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`);
+                this.LogInfoMessage(`Prometheus scrapes ready and live on ${this.options.endpoint}:${this.options.prometheusClusterPort}/metrics`);
             });
         } catch (error)
         {
@@ -231,26 +232,26 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
             if (cluster.workers && cluster.workers[id]) {
                 const worker = cluster.workers[id] as Worker;
                 if (worker.process) {
-                    this.LogEx(chalk.grey(`Sending terminate message `) + chalk.yellow(`(initiated by ${signal})`) + chalk.grey(` for worker PID: ${worker.process.pid}`));
+                    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.LogEx(chalk.red(`MasterProcessBase:#_KillWorker() (1): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
+                        this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker() (1): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
                         return false;
                     }
                     return true;
                 } else {
-                    this.LogEx(chalk.red(`MasterProcessBase:#_KillWorker(): Could not kill worker with id: [${id}]. The process does not exists`));
+                    this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker(): Could not kill worker with id: [${id}]. The process does not exists`));
                     return false;
                 }
             } else {
-                this.LogEx(chalk.red(`MasterProcessBase:#_KillWorker(): Could not kill worker with id: [${id}]. Worker does not exist within workers collection`));
+                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.LogEx(chalk.red(`MasterProcessBase:#_KillWorker() (2): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
+            this.LogInfoMessage(chalk.red(`MasterProcessBase:#_KillWorker() (2): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
             return false;
         }
     }
@@ -278,11 +279,11 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                     return this.#_KillWorker(id, signal, killProcess);
                 }
             } else {
-                this.LogEx(chalk.yellow(`MasterProcessBase:KillWorker(): Not allowed to kill the last worker process.`));
+                this.LogInfoMessage(chalk.yellow(`MasterProcessBase:KillWorker(): Not allowed to kill the last worker process.`));
                 return false;
             }
         } catch (error) {
-            this.LogEx(chalk.red(`MasterProcessBase:KillWorker(): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
+            this.LogInfoMessage(chalk.red(`MasterProcessBase:KillWorker(): id: [${id}], signal: [${signal}], killProcess: [${killProcess}], error: [${error}]`));
             return false;
         }
     }
@@ -303,7 +304,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                 }
             });
         } catch (error) {
-            this.LogEx(chalk.red(`MasterProcessBase:KillWorkers(): signal: [${signal}], keepOne: [${keepOne}], error: [${error}]`));
+            this.LogInfoMessage(chalk.red(`MasterProcessBase:KillWorkers(): signal: [${signal}], keepOne: [${keepOne}], error: [${error}]`));
         }
     }
 
@@ -393,11 +394,11 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
         worker.on('exit', (code, signal) => {
             if (signal) {
-                this.LogEx(`Worker: ${worker.process.pid} was killed by signal: ${signal}`);
+                this.LogInfoMessage(`Worker: ${worker.process.pid} was killed by signal: ${signal}`);
             } else if (code !== 0) {
-                this.LogEx(`Worker: ${worker.process.pid} exited with error code: ${code}`);
+                this.LogInfoMessage(`Worker: ${worker.process.pid} exited with error code: ${code}`);
             } else {
-                this.LogEx(`Worker: ${worker.process.pid} exited successfully, code: ${code}, signal: ${signal}`);
+                this.LogInfoMessage(`Worker: ${worker.process.pid} exited successfully, code: ${code}, signal: ${signal}`);
             }
         });
 
@@ -416,8 +417,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
         worker.on('error', (error) => {
             const message = chalk.red(`#SpawnWorker():worker.on('error'): Error: [${error}]`);
-            this.#LogDebugMessage(message);
-            this.LogEx(message);
+            this.LogErrorMessage(message);
         });
 
         return worker.id;
@@ -443,9 +443,8 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
     SetupServerEx = async () =>
     {
         this.ProcessStartup();
-        const LogEx = this.LogEx;
 
-        LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
+        this.LogInfoMessage(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
 
         this.LogSystemTelemetry();
 
@@ -453,15 +452,15 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         // setup connections between the workers
         if (this.options.wssServer === true) {
             if (this.options.useRedisAdaptor) {
-                LogEx(`Using Redis for socket.io cluster management (master)`);
+                this.LogInfoMessage(`Using Redis for socket.io cluster management (master)`);
             } else {
-                LogEx(`Using nodejs cluster mode for socket.io cluster management`);
+                this.LogInfoMessage(`Using nodejs cluster mode for socket.io cluster management`);
                 setupPrimary();
             }
         }
 
         if (this.options.prometheusSupport === true) {
-            this.#SetupPrometheusForMaster(LogEx);
+            this.#SetupPrometheusForMaster();
         }
 
         const numCPUs = await this.GetNumCPUs();
@@ -469,34 +468,34 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
             this.#SpawnWorker();
         }
 
-        this.#InitCluster(LogEx);
+        this.#InitCluster();
 
         cluster.on('listening', (worker, address) =>
         {
-            LogEx(`Worker process ${worker.process.pid} is listening at address: ${JSON.stringify(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 => 
         {
-            LogEx(`Worker process ${worker.process.pid} is online`);
+            this.LogInfoMessage(`Worker process ${worker.process.pid} is online`);
         });
 
         cluster.on('exit', (worker, code, signal) => {
             if ((code !== null && code === 0) || (signal === 'SIGINT')) {
-                LogEx(chalk.green(`Process ${worker.process.pid} terminated gracefully with code: ${code}, signal: ${signal}`));
+                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();
-                LogEx(chalk.red(`Process ${worker.process.pid} terminated with code: ${code}, signal: ${signal}`));
+                this.LogInfoMessage(chalk.red(`Process ${worker.process.pid} terminated with code: ${code}, signal: ${signal}`));
             } else {
                 this.DecWorkers();
-                LogEx(chalk.red(`worker ${worker.process.pid} died`));
-                LogEx(chalk.red(`code: ${code}`));
-                LogEx(chalk.red(`signal: ${signal}`));
-                LogEx(chalk.red('process terminated in an error state'));
+                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) {
-                    LogEx(chalk.magenta(`Attemping to respawn worker`));
+                    this.LogInfoMessage(chalk.magenta(`Attemping to respawn worker`));
                     this.#SpawnWorker();
                 }
             }
@@ -526,35 +525,35 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
                 if (this.GetUIController() !== null)
                 {
-                    LogEx('Destroy the user interface controller.');
+                    this.LogInfoMessage('Destroy the user interface controller.');
                     this.GetUIController().DestroyUI();
                 }
 
                 if (signal) {
-                    LogEx(this.GetSignalColour(signal)(`Main Process (masterprocess): ${process.pid} received signal: ${signal}`));
+                    this.LogInfoMessage(this.GetSignalColour(signal)(`Main Process (masterprocess): ${process.pid} received signal: ${signal}`));
                 } else {
-                    LogEx(this.GetSignalColour(null)(`Main Process (masterprocess): ${process.pid} received Terminate without signal.`));
+                    this.LogInfoMessage(this.GetSignalColour(null)(`Main Process (masterprocess): ${process.pid} received Terminate without signal.`));
                 }
 
-                LogEx(`De-Registering service.`);
+                this.LogInfoMessage(`De-Registering service.`);
                 //@@ De-register here ...
 
                 if (this.#httpServer !== null) {
-                    LogEx(`Closing httpServer.`);
+                    this.LogInfoMessage(`Closing httpServer.`);
                     await this.#httpServer.close();
                     this.#httpServer = null;
                 }
 				
-                LogEx(`Stopping instruments.`);
+                this.LogInfoMessage(`Stopping instruments.`);
                 //@@StopInstruments(this.instruments);
 
                 //@@endpublish was here (and working ...)
 
-                LogEx('Killing Workers.');
+                this.LogInfoMessage('Killing Workers.');
                 this.KillWorkers(signal);
 
                 if (this.options.useDatabase) {
-                    LogEx(`Ending database connections and pools.`);
+                    this.LogInfoMessage(`Ending database connections and pools.`);
                     await this.TerminateDatabase();
                     //await this.accessLayer.enddatabase();
                 }
@@ -562,7 +561,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
                 // Now allow some time for the workers to die and send any remaining messages ...
                 //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
                 if (this.InstrumentController) {
-                    LogEx(`Ending publisher.`);
+                    this.LogInfoMessage(`Ending publisher.`);
                     setTimeout(() => {
                         if (this.InstrumentController) {
                             this.InstrumentController.InstrumentTerminate();
@@ -572,11 +571,11 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
                 if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
                     setTimeout(() => {
-                        LogEx(`Performing process.exit(0).`);
+                        this.LogInfoMessage(`Performing process.exit(0).`);
                         process.exit(0);
                     }, this.#childProcessExitTime + this.#masterProcessExitTime); // Give the workers time to terminate gracefully
                 } else {
-                    LogEx(`Performing process.exit(0) - Immediate.`);
+                    this.LogInfoMessage(`Performing process.exit(0) - Immediate.`);
                 }
             }
         }
@@ -595,9 +594,9 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         {
             if (code === 0)
             {
-                LogEx(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
+                this.LogInfoMessage(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
             } else {
-                LogEx(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
+                this.LogInfoMessage(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
             }
         });
 
@@ -609,21 +608,21 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
         this.MasterStarted();
 
-        LogEx(chalk.green(`Master process:${process.pid} started`));
+        this.LogInfoMessage(chalk.green(`Master process:${process.pid} started`));
     }
 
     BroadcastDataToWorkers = (command: any, data: any) => {
         try {
             for (const id in cluster.workers) {
                 try {
-                    //@@LogEx(chalk.gray(`Sending message to worker PID: ${cluster.workers[id].process.pid}`));
+                    //@@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) {
-                    //@@LogEx(error);
+                    //@@this.LogInfoMessage(error);
                 }
             }
         } catch (error) {
-            //@@LogEx(error);
+            //@@this.LogInfoMessage(error);
         }
     }
 }

package/src/processbase.ts

@@ -71,21 +71,11 @@ export abstract class ProcessBase extends STSOptionsBase implements IProcessBase
     }
 
     LogErrorMessage(message: any) {
-        const msg = this.#GetFormattedLogMessage(message);
-        this.options.logger.error(msg);
-
-        this.UpdateInstrument(Gauge.LOGGER, {
-            LogMessage: msg
-        } as InstrumentLogTelemetry);
+        this.options.logger.error(this.#GetFormattedLogMessage(message));
     }
 
     LogInfoMessage(message: any) {
-        const msg = this.#GetFormattedLogMessage(message);
-        this.options.logger.info(msg);
-
-        this.UpdateInstrument(Gauge.LOGGER, {
-            LogMessage: msg
-        } as InstrumentLogTelemetry);
+        this.options.logger.info(this.#GetFormattedLogMessage(message));
     }
 
     LogMessageToLoggerInstrument(message: any) {
@@ -272,10 +262,6 @@ export abstract class ProcessBase extends STSOptionsBase implements IProcessBase
         return this.#instrumentController;
     }
 
-    LogEx = (message: any) => {
-        this.LogInfoMessage(message);
-    }
-
     InstrumentExists(instrumentName: Gauge): boolean
     {
         if (this.#instrumentController) {
@@ -347,13 +333,13 @@ export abstract class ProcessBase extends STSOptionsBase implements IProcessBase
                     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)}]`));
+                            this.LogInfoMessage(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}]`));
+                            this.LogInfoMessage(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}]`));
+                        this.LogInfoMessage(chalk.red(`Unable to get resources from the database. Is the database running? Error: [${error}]`));
                         //@@exit(1);
                     }
                 })();
@@ -399,17 +385,17 @@ export abstract class ProcessBase extends STSOptionsBase implements IProcessBase
 
         const hostaddr = GetFirstNetworkInterface();
         if (hostaddr !== null) {
-            this.LogEx(`Host Address: ${hostaddr}`);
+            this.LogInfoMessage(`Host Address: ${hostaddr}`);
         } else {
-            this.LogEx(`Unknown Host Address.`);
+            this.LogInfoMessage(`Unknown Host Address.`);
         }
-        this.LogEx(`Server starting with ${numCPUs} Cores/Threads`);
+        this.LogInfoMessage(`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)}`);
+        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) => {

package/src/serverprocessbase.ts

@@ -167,36 +167,35 @@ export class ServerProcessBase extends ProcessBase
 
         if (this.options.clusterMode) {
             if (this.options.useRedisAdaptor) {
-                this.LogEx(`Using Redis for socket.io cluster management (worker)`);
+                this.LogInfoMessage(`Using Redis for socket.io cluster management (worker)`);
                 if (this.options.redisAdaptorUrl) {
-                    this.LogEx(`Redis url: [${this.options.redisAdaptorUrl}]`);
+                    this.LogInfoMessage(`Redis url: [${this.options.redisAdaptorUrl}]`);
                     this.#redisClient = createClient({url: this.options.redisAdaptorUrl});
                 } else {
-                    this.LogEx(`Redis url: [localhost]`);
+                    this.LogInfoMessage(`Redis url: [localhost]`);
                     this.#redisClient = createClient();
                 }
                 await this.#redisClient.connect();
                 this.#io.adapter(createAdapter(this.#redisClient) as any);
-                this.LogEx(`Redis successfully connected.`);
+                this.LogInfoMessage(`Redis successfully connected.`);
             } else {
                 this.#io.adapter(clusterCreateAdapter() as any);
-                this.LogEx(`Using nodejs cluster mode for socket.io cluster management`);
+                this.LogInfoMessage(`Using nodejs cluster mode for socket.io cluster management`);
             }
         } else {
-            this.LogEx(`Not using any adaptors for socket.io cluster management.}`);
+            this.LogInfoMessage(`Not using any adaptors for socket.io cluster management.}`);
         }
 
         // To use a seperate socket server, the code below can be applied.
         // this.#io = require("socket.io")(options);
         // this.#io.adapter(createAdapter());
         // this.#io.listen(3006);
-        // LogEx(`socket.io init`);
 
         this.#io.engine.on("connection_error", (err) => {
-            this.LogEx(err.req); // the request object
-            this.LogEx(err.code); // the error code, for example 1
-            this.LogEx(err.message); // the error message, for example "Session ID unknown"
-            this.LogEx(err.context); // some additional error context
+            this.LogInfoMessage(err.req); // the request object
+            this.LogInfoMessage(err.code); // the error code, for example 1
+            this.LogInfoMessage(err.message); // the error message, for example "Session ID unknown"
+            this.LogInfoMessage(err.context); // some additional error context
         });
     }
 
@@ -226,7 +225,7 @@ export class ServerProcessBase extends ProcessBase
             //@@chmodSync(this.options.port, 511);
         }).on('listening', () =>
         {
-            this.LogEx(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+            this.LogInfoMessage(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
         });
     }
 
@@ -237,7 +236,7 @@ export class ServerProcessBase extends ProcessBase
             this.LogInfoMessage('TCP Server is running on port ' + this.options.listenPort + '.');
         }).on('listening', () =>
         {
-            this.LogEx(`TCP live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+            this.LogInfoMessage(`TCP live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
         });
     }
 
@@ -253,7 +252,7 @@ export class ServerProcessBase extends ProcessBase
             this.LogInfoMessage('JSON RPC 2.0 Server is running on port ' + this.options.listenPort + '.');
         }).on('listening', () =>
         {
-            this.LogEx(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+            this.LogInfoMessage(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
         });
     }
 
@@ -283,20 +282,20 @@ export class ServerProcessBase extends ProcessBase
             if (!this.options.clusterMode) {
                 if (this.GetUIController() !== null)
                 {
-                    this.LogEx('Destroy the user interface controller.');
+                    this.LogInfoMessage('Destroy the user interface controller.');
                     this.GetUIController().DestroyUI();
                 }
         
                 if (signal) {
-                    this.LogEx(this.GetSignalColour(signal)(`Main Process (singleprocess): ${process.pid} received signal: ${signal}`));
+                    this.LogInfoMessage(this.GetSignalColour(signal)(`Main Process (singleprocess): ${process.pid} received signal: ${signal}`));
                 } else {
-                    this.LogEx(this.GetSignalColour(null)(`Main Process (singleprocess): ${process.pid} received Terminate without signal.`));
+                    this.LogInfoMessage(this.GetSignalColour(null)(`Main Process (singleprocess): ${process.pid} received Terminate without signal.`));
                 }
             }
 
             if (this.options.wssServer === true && this.#io !== null)
             {
-                this.LogEx(`Disconnect Sockets.`);
+                this.LogInfoMessage(`Disconnect Sockets.`);
                 if (this.socketIoServerHelper !== null) {
                     this.socketIoServerHelper.DisconnectSockets();
                 } else {
@@ -310,33 +309,33 @@ export class ServerProcessBase extends ProcessBase
             if (this.#httpServer) {
                 if (this.options.serverType === STSServerType.TCPRAW_TLS) {
                     this.#sockets.forEach((socket: net.Socket, index, array) => {
-                        this.LogEx(chalk.yellow(`TCP Socket destroy, remote address: [${socket.remoteAddress}], remote port: [${socket.remotePort}]`));
+                        this.LogInfoMessage(chalk.yellow(`TCP Socket destroy, remote address: [${socket.remoteAddress}], remote port: [${socket.remotePort}]`));
                         socket.destroy();
                         //socket.end();
                     });
                 }
-                this.LogEx(`Closing httpServer.`);
+                this.LogInfoMessage(`Closing httpServer.`);
                 await this.#httpServer.close();
             }
             
             if (this.options.useDatabase) {
-                this.LogEx(`Ending database connections and pools.`);
+                this.LogInfoMessage(`Ending database connections and pools.`);
                 await this.TerminateDatabase();
                 //await this.accessLayer.enddatabase();
             }
 
             if (this.options.clusterMode) {
-                this.LogEx(`Performing exit value: [${clusterPerformExit}]`);
+                this.LogInfoMessage(`Performing exit value: [${clusterPerformExit}]`);
                 if (clusterPerformExit) {
-                    this.LogEx(`Process will self terminate with process.exit(0).`);
+                    this.LogInfoMessage(`Process will self terminate with process.exit(0).`);
                 } else {
-                    this.LogEx(`Child process will not self terminate. Terminate will be handled by master process.`);
+                    this.LogInfoMessage(`Child process will not self terminate. Terminate will be handled by master process.`);
                 }
             }
 
             //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
             if (this.InstrumentController) {
-                this.LogEx(`Ending publisher.`);
+                this.LogInfoMessage(`Ending publisher.`);
                 setTimeout(() => {
                     //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
                     if (this.InstrumentController) {
@@ -362,15 +361,15 @@ export class ServerProcessBase extends ProcessBase
             } else {
                 if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
                     setTimeout(() => {
-                        this.LogEx(`Performing process.exit(0).`);
+                        this.LogInfoMessage(`Performing process.exit(0).`);
                         process.exit(0);
                     }, this.#masterProcessExitTime); // Give the workers time to terminate gracefully
                 } else {
-                    this.LogEx(`Performing process.exit(0) - Immediate.`);
+                    this.LogInfoMessage(`Performing process.exit(0) - Immediate.`);
                 }
             }
         } else {
-            this.LogEx(`Process already terminating.`);
+            this.LogInfoMessage(`Process already terminating.`);
         }
     }
 

package/src/singleprocessbase.ts

@@ -91,8 +91,8 @@ export class SingleProcessBase extends ServerProcessBase implements ISingleProce
             this.expressServer = new STSExpressServer(this.options, this);
         }
 
-        this.LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
-        this.LogEx(`Master process:${process.pid} started`);
+        this.LogInfoMessage(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
+        this.LogInfoMessage(`Master process:${process.pid} started`);
 
         this.LogSystemTelemetry();
 
@@ -106,9 +106,9 @@ export class SingleProcessBase extends ServerProcessBase implements ISingleProce
 
         process.on('exit', (code) => {
             if (code === 0) {
-                this.LogEx(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
+                this.LogInfoMessage(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
             } else {
-                this.LogEx(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
+                this.LogInfoMessage(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
             }
         });
 
@@ -116,7 +116,7 @@ export class SingleProcessBase extends ServerProcessBase implements ISingleProce
 
         this.ProcessStarted();
 
-        this.LogEx(chalk.green(`Main process:${process.pid} started`));
+        this.LogInfoMessage(chalk.green(`Main process:${process.pid} started`));
     }
 
     async TerminateApplication()

package/src/tcpserver/appmaster.ts

@@ -307,7 +307,7 @@ export class AppMaster extends MasterProcessBase
             this.#LogInfoMessage('JSON RPC 2.0 Server is running on port ' + this.options.listenPort + '.');
         }).on('listening', () =>
         {
-            this.LogEx(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+            this.LogInfoMessage(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
         });
         return server;
     }
@@ -512,13 +512,13 @@ export class AppMaster extends MasterProcessBase
     }
 
     #StartRAFTService = async () => {
-        this.LogEx(chalk.green(`---[ RAFT Protocol Starting ]---`));
+        this.LogInfoMessage(chalk.green(`---[ RAFT Protocol Starting ]---`));
         this.#server = await this.#SetupJSONRPCServer();
         this.#StartElectionTimeout();
     }
 
     #ChangeState(newState: AppMasterRAFTState) {
-        this.LogEx(chalk.magenta(`${this.#GetLogPrefix()}: State Change, From: [${this.#RAFTState.toString()}] --> To: [${newState.toString()}]`));
+        this.LogInfoMessage(chalk.magenta(`${this.#GetLogPrefix()}: State Change, From: [${this.#RAFTState.toString()}] --> To: [${newState.toString()}]`));
         this.#RAFTState = newState;
     }
 

package/src/workerprocessbase.ts

@@ -129,7 +129,7 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
             this.expressServer = new STSExpressServer(this.options, this);
         }
 
-        this.LogEx(`Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
+        this.LogInfoMessage(`Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
 
         // eslint-disable-next-line  @typescript-eslint/no-explicit-any
         process.on('message', async (msg: any) => {
@@ -153,15 +153,15 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
                 switch (msg.command)
                 {
                 case 'Terminate' :
-                    this.LogEx(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
+                    this.LogInfoMessage(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
                     await this.Terminate(true, false); // Don't kill the child process here, the master will take care of that ...
                     break;
                 case 'TerminateAndKill' :
-                    this.LogEx(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
+                    this.LogInfoMessage(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
                     await this.Terminate(true, true);
                     break;
                 case 'Message' :
-                    //this.LogEx(chalk.grey(`Received ` + chalk.bold.italic(`Message`) + ` message from master thread`));
+                    //this.LogInfoMessage(chalk.grey(`Received ` + chalk.bold.italic(`Message`) + ` message from master thread`));
                     this.ReceivedMessageFromMaster(msg.data);
                     break;
                 case 'Response' : // General response to a req/response interaction
@@ -174,13 +174,13 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         // https://en.wikipedia.org/wiki/Signal_(IPC)
         process.on('SIGTERM', async () =>
         {
-            this.LogEx(`SIGTERM signal received for worker: ${process.pid}`);
+            this.LogInfoMessage(`SIGTERM signal received for worker: ${process.pid}`);
             await this.Terminate(true, true);
         });
 
         process.on('SIGINT', async () =>
         {
-            this.LogEx(`SIGINT signal received for worker: ${process.pid}`);
+            this.LogInfoMessage(`SIGINT signal received for worker: ${process.pid}`);
             await this.Terminate(true, true);
         });
 
@@ -188,6 +188,6 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
 
         this.WorkerStarted();
 
-        this.LogEx(chalk.green(`Worker process:${process.pid} started`));
+        this.LogInfoMessage(chalk.green(`Worker process:${process.pid} started`));
     };
 }