@nsshunt/stsappframework 3.1.236 → 3.1.237

package/dist/stsappframework.mjs

@@ -0,0 +1,1979 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _options, _instrumentController, _systemInformationInterval, _socketIoServerHelper, _accessLayer, _ProcessBase_instances, GetFormattedLogMessage_fn, _UpdatePGPoolManagerInstrument, _options2, _masterProcessExitTime, _childProcessExitTime, _siValueObject, _httpServer, _metricsServer, _aggregatorRegistry, _checkLatency, _killWorkers, _workers, _shuttingDown, _agentManager, _MasterProcessBase_instances, LogErrorMessage_fn, LogDebugMessage_fn, WorkerMessageEvent_fn, _InitCluster, _SetupPrometheusForMaster, _CheckLatency, _GetLatency, _LatencyRequestCompleted, __KillWorker, _UpdateWorkersInstrument, _processIPCCommand, _SpawnWorker, _tinyEmitter, _socketCollection, _id, _ServerNetworkMiddleware_instances, LogSillyMessage_fn, LogErrorMessage_fn2, _GetRequestContentSize, _app, _masterProcessExitTime2, _io, _redisClient, _httpServer2, _expressServer, _sockets, _shuttingDown2, _SetupPrometheusEndPoints, _SetupTLSServer, _SetupRPCServer, _SetupWSSServer, _GetTLSOptions, _SetupExpressServer, _SetupTCPRawServer, _SetupJSONRPCServer, _inFlightMessage, _requestResponseMessageTimeout, _pingTimeout, _SendMessageToParentProcess, _stsApp, _router, _stsApp2, _options3;
+import { CheckValidChar, ModelDelimeter, Sleep, STSOptionsBase } from "@nsshunt/stsutils";
+import fs from "node:fs";
+import si from "/home/runner/work/stsappframework/stsappframework/node_modules/systeminformation/lib/index.js";
+import axios from "axios";
+import cluster from "node:cluster";
+import chalk from "/home/runner/work/stsappframework/stsappframework/node_modules/chalk/source/index.js";
+import express, { Router } from "/home/runner/work/stsappframework/stsappframework/node_modules/express/index.js";
+import { setupPrimary, createAdapter as createAdapter$1 } from "/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/cluster-adapter/dist/index.js";
+import { createServer as createServer$1 } from "node:https";
+import { createServer } from "node:http";
+import { AggregatorRegistry, collectDefaultMetrics, Counter, register } from "/home/runner/work/stsappframework/stsappframework/node_modules/prom-client/index.js";
+import { goptions, AgentManager, STSAxiosConfig } from "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsconfig/dist/stsconfig.mjs";
+import { Gauge, TransportType, GetInstruments, PublishInstrumentController, GaugeTypes, RequestLoggerMiddleware, RequestLoggerMiddlewareEventName } from "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsobservability/dist/stsobservability.mjs";
+import pidusage from "/home/runner/work/stsappframework/stsappframework/node_modules/pidusage/index.js";
+import { memoryUsage } from "/home/runner/work/stsappframework/stsappframework/node_modules/process/browser.js";
+import os from "os";
+import { IDBAccessLayerEvents, DBAccessLayerManager, accessLayerType } from "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsdatamanagement/dist/dbaccess.js";
+import { StatusCodes } from "/home/runner/work/stsappframework/stsappframework/node_modules/http-status-codes/build/es/index.js";
+import { TinyEmitter } from "/home/runner/work/stsappframework/stsappframework/node_modules/tiny-emitter/index.js";
+import Transport from "/home/runner/work/stsappframework/stsappframework/node_modules/winston-transport/dist/index.js";
+import tls from "node:tls";
+import { Server } from "/home/runner/work/stsappframework/stsappframework/node_modules/socket.io/wrapper.mjs";
+import cors from "/home/runner/work/stsappframework/stsappframework/node_modules/cors/lib/index.js";
+import cookieParser from "/home/runner/work/stsappframework/stsappframework/node_modules/cookie-parser/index.js";
+import { v4 } from "/home/runner/work/stsappframework/stsappframework/node_modules/uuid/dist/esm-browser/index.js";
+import onHeaders from "/home/runner/work/stsappframework/stsappframework/node_modules/on-headers/index.js";
+import { createAdapter } from "/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/redis-streams-adapter/dist/index.js";
+import { createClient } from "/home/runner/work/stsappframework/stsappframework/node_modules/redis/dist/index.js";
+import jayson from "/home/runner/work/stsappframework/stsappframework/node_modules/jayson/index.js";
+function CreateServiceProcessContext(serviceName, serviceVersion, serviceInstanceId, hostName, processId, parentProcessId) {
+  const checkParams = [
+    ["servicename", serviceName],
+    ["serviceversion", serviceVersion],
+    ["hostname", hostName],
+    ["serviceInstanceId", serviceInstanceId]
+  ];
+  CheckValidChar(checkParams);
+  return {
+    nid: `${serviceName}${ModelDelimeter.COMPONENT_SEPERATOR}${serviceVersion}${ModelDelimeter.SEPERATOR}${serviceInstanceId}${ModelDelimeter.COMPONENT_SEPERATOR}${hostName}${ModelDelimeter.NID_SEPERATOR}${processId.toString()}${ModelDelimeter.COMPONENT_SEPERATOR}${parentProcessId.toString()}`,
+    serviceName,
+    serviceVersion,
+    serviceInstanceId,
+    hostName,
+    processId: processId.toString(),
+    parentProcessId: parentProcessId.toString()
+  };
+}
+var IPCMessageCommand = /* @__PURE__ */ ((IPCMessageCommand2) => {
+  IPCMessageCommand2["AddWorker"] = "AddWorker";
+  IPCMessageCommand2["DeleteWorker"] = "DeleteWorker";
+  IPCMessageCommand2["GetConfig"] = "GetConfig";
+  return IPCMessageCommand2;
+})(IPCMessageCommand || {});
+const iss = `https://stscore.stsmda.org/oauth2/v2.0`;
+function GetNetworkInterfaces() {
+  const nets = os.networkInterfaces();
+  const results = {};
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name]) {
+      if (net.family === "IPv4" && !net.internal) {
+        if (!results[name]) {
+          results[name] = [];
+        }
+        results[name].push(net.address);
+      }
+    }
+  }
+  return results;
+}
+function GetFirstNetworkInterface() {
+  const nics = GetNetworkInterfaces();
+  let hostaddr = null;
+  for (const nic in nics) {
+    const val = nics[nic];
+    if (val.length > 0) {
+      hostaddr = val[0];
+      break;
+    }
+  }
+  return hostaddr;
+}
+class ProcessBase extends TinyEmitter {
+  //#redisMessageHandler: RedisMessageHandler | null = null;
+  constructor(options) {
+    super();
+    __privateAdd(this, _ProcessBase_instances);
+    __privateAdd(this, _options);
+    __privateAdd(this, _instrumentController, null);
+    __privateAdd(this, _systemInformationInterval, null);
+    __privateAdd(this, _socketIoServerHelper, null);
+    __privateAdd(this, _accessLayer, null);
+    __publicField(this, "ProcessStartup", () => {
+      const ExecuteGetStats = async () => {
+        const startTime = performance.now();
+        if (__privateGet(this, _instrumentController)) {
+          const stats = await pidusage(process.pid);
+          let useStatsCpu = stats.cpu;
+          if (useStatsCpu < 0.01) {
+            useStatsCpu = 0.01;
+          }
+          __privateGet(this, _instrumentController).UpdateInstrument(Gauge.CPU_LOAD_GAUGE, {
+            val: useStatsCpu
+          });
+        }
+        const usage = memoryUsage();
+        const telemetry = {
+          r: usage.rss,
+          t: usage.heapTotal,
+          u: usage.heapUsed,
+          x: usage.external,
+          a: usage.arrayBuffers
+        };
+        this.UpdateInstrument(Gauge.OBJECT_GAUGE, {
+          val: telemetry
+        });
+        this.CollectAdditionalTelemetry();
+        const totalTime = performance.now() - startTime;
+        const nextLoopTime = goptions.systemInformationInterval - totalTime;
+        __privateSet(this, _systemInformationInterval, setTimeout(ExecuteGetStats, nextLoopTime).unref());
+      };
+      __privateSet(this, _systemInformationInterval, setTimeout(ExecuteGetStats, goptions.systemInformationInterval).unref());
+      if (this.options.useDatabase) {
+        this.accessLayer;
+      }
+    });
+    __publicField(this, "UpdateInstrument", (instrumentName, telemetry) => {
+      if (__privateGet(this, _instrumentController)) {
+        __privateGet(this, _instrumentController).UpdateInstrument(instrumentName, telemetry);
+      }
+    });
+    __publicField(this, "ProcessExit", (processExitDelay) => {
+      if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
+        setTimeout(() => {
+          this.LogInfoMessage(`Performing process.exit(0).`);
+          process.exit(0);
+        }, processExitDelay);
+      } else {
+        this.LogInfoMessage(`Performing process.exit(0) - Immediate.`);
+      }
+    });
+    __publicField(this, "TerminateInstrumentController", () => {
+      if (this.InstrumentController) {
+        this.LogInfoMessage(`ProcessBase:TerminateInstrumentController()`);
+        setTimeout(() => {
+          if (this.InstrumentController) {
+            this.InstrumentController.EndPublish();
+          }
+        }, 100);
+      }
+    });
+    __publicField(this, "TerminateUIController", () => {
+      if (this.GetUIController() !== null) {
+        this.LogInfoMessage("ProcessBase:TerminateUIController(): Destroy the user interface controller.");
+        this.GetUIController().DestroyUI();
+      }
+    });
+    __privateAdd(this, _UpdatePGPoolManagerInstrument, (data) => {
+      this.UpdateInstrument(Gauge.CONNECTION_POOL_TOTAL_GAUGE, {
+        val: data.totalCount
+      });
+      this.UpdateInstrument(Gauge.CONNECTION_POOL_IDLE_GAUGE, {
+        val: data.idleCount
+      });
+      this.UpdateInstrument(Gauge.CONNECTION_POOL_WAITING_GAUGE, {
+        val: data.waitingCount
+      });
+    });
+    __publicField(this, "GetNumCPUs", async () => {
+      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;
+    });
+    __publicField(this, "LogSystemTelemetry", async () => {
+      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)}`);
+    });
+    __publicField(this, "GetSignalColour", (signal) => {
+      let msgcolor = null;
+      if (signal === "SIGINT") {
+        msgcolor = chalk.yellow;
+      } else {
+        msgcolor = chalk.red;
+      }
+      return msgcolor;
+    });
+    __privateSet(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
+      );
+    }
+  }
+  LogErrorMessage(message) {
+    this.options.logger.error(__privateMethod(this, _ProcessBase_instances, GetFormattedLogMessage_fn).call(this, message));
+  }
+  LogInfoMessage(message) {
+    this.options.logger.info(__privateMethod(this, _ProcessBase_instances, GetFormattedLogMessage_fn).call(this, message));
+  }
+  LogMessageToLoggerInstrument(message) {
+    this.UpdateInstrument(Gauge.LOGGER, {
+      LogMessage: __privateMethod(this, _ProcessBase_instances, GetFormattedLogMessage_fn).call(this, message)
+    });
+  }
+  get options() {
+    return __privateGet(this, _options);
+  }
+  get shuttingDown() {
+    return false;
+  }
+  SetupInstrumentation() {
+    if (!this.options.serviceProcessContext) {
+      return;
+    }
+    let publishTransportOptions = 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 {
+      return;
+    }
+    const httpServer = goptions.STSServerType.localeCompare("EXPRESS") === 0 || goptions.STSServerType.localeCompare("EXPRESS_TLS") === 0;
+    const instrumentControllerOptions = {
+      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: 5e3,
+      //@@
+      instrumentDefinitions: GetInstruments("service"),
+      publishTransportBaseOptions: publishTransportOptions,
+      autoStart: true
+      /*
+      [
+          ...this.#GetDefaultServiceInstruments(httpServer),
+          ...this.GetAdditionalInstruments()
+      ]
+      */
+    };
+    __privateSet(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() {
+    return [];
+  }
+  CollectAdditionalTelemetry() {
+  }
+  get InstrumentController() {
+    return __privateGet(this, _instrumentController);
+  }
+  InstrumentExists(instrumentName) {
+    if (__privateGet(this, _instrumentController)) {
+      return __privateGet(this, _instrumentController).InstrumentExists(instrumentName);
+    }
+    return false;
+  }
+  async ProcessTerminate() {
+    this.emit("ProcessTerminate");
+    if (__privateGet(this, _systemInformationInterval)) {
+      clearTimeout(__privateGet(this, _systemInformationInterval));
+    }
+    __privateSet(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() {
+    return null;
+  }
+  get socketIoServerHelper() {
+    return __privateGet(this, _socketIoServerHelper);
+  }
+  set socketIoServerHelper(value) {
+    __privateSet(this, _socketIoServerHelper, value);
+  }
+  async TerminateDatabase() {
+    if (__privateGet(this, _accessLayer)) {
+      const logPrefix = `ProcessBase:TerminateDatabase():${process.pid}:`;
+      this.LogInfoMessage(`${logPrefix} Ending database connections and pools.`);
+      __privateGet(this, _accessLayer).off(IDBAccessLayerEvents.UpdateInstruments, __privateGet(this, _UpdatePGPoolManagerInstrument));
+      await __privateGet(this, _accessLayer).EndDatabase();
+    }
+  }
+  get accessLayer() {
+    if (this.options.useDatabase) {
+      if (__privateGet(this, _accessLayer) === null) {
+        __privateSet(this, _accessLayer, new DBAccessLayerManager().CreateAccessLayer({
+          accessLayerType: accessLayerType.postgresql,
+          accessLayerOptions: {
+            logger: this.options.logger,
+            usedefaultdb: false
+          }
+        }));
+        __privateGet(this, _accessLayer).on(IDBAccessLayerEvents.UpdateInstruments, __privateGet(this, _UpdatePGPoolManagerInstrument));
+        (async () => {
+          try {
+            const retVal = await this.accessLayer.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 __privateGet(this, _accessLayer);
+    }
+    return null;
+  }
+  emit(event, ...arg) {
+    super.emit(event, arg);
+    return this;
+  }
+  on(event, callback) {
+    super.on(event, callback);
+    return this;
+  }
+  off(event, callback) {
+    super.off(event, callback);
+    return this;
+  }
+  /*@@
+  get redisMessageHandler(): RedisMessageHandler {
+      return this.#redisMessageHandler as RedisMessageHandler;
+  }
+  */
+}
+_options = new WeakMap();
+_instrumentController = new WeakMap();
+_systemInformationInterval = new WeakMap();
+_socketIoServerHelper = new WeakMap();
+_accessLayer = new WeakMap();
+_ProcessBase_instances = new WeakSet();
+GetFormattedLogMessage_fn = function(message) {
+  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}`);
+};
+_UpdatePGPoolManagerInstrument = new WeakMap();
+class STSTransportLoggerWinston extends Transport {
+  constructor(opts) {
+    super(opts);
+    __privateAdd(this, _options2);
+    __privateSet(this, _options2, opts);
+  }
+  log(info, callback) {
+    __privateGet(this, _options2).stsApp.LogMessageToLoggerInstrument(info.message);
+    this.emit("logged", info);
+    callback();
+  }
+}
+_options2 = new WeakMap();
+class MasterProcessBase extends ProcessBase {
+  constructor(options) {
+    super(options);
+    __privateAdd(this, _MasterProcessBase_instances);
+    //static WORKER_MESSAGE_EVENT = 'sts_worker_message_event';
+    __privateAdd(this, _masterProcessExitTime, goptions.masterProcessExitTime);
+    __privateAdd(this, _childProcessExitTime, goptions.childProcessExitTime);
+    __privateAdd(this, _siValueObject, {
+      currentLoad: "currentLoad"
+    });
+    __privateAdd(this, _httpServer, null);
+    // Prometheus cluster server. See https://github.com/siimon/prom-client/blob/master/example/cluster.js
+    __privateAdd(this, _metricsServer, null);
+    __privateAdd(this, _aggregatorRegistry, null);
+    __privateAdd(this, _checkLatency, null);
+    __privateAdd(this, _killWorkers, {});
+    __privateAdd(this, _workers, 1);
+    // Start at 1 becuase of main thread
+    __privateAdd(this, _shuttingDown, false);
+    __privateAdd(this, _agentManager);
+    __privateAdd(this, _InitCluster, () => {
+      cluster.on("listening", (worker, address) => {
+        this.emit("clusterListening", worker, address);
+        let allListening = true;
+        for (const worker2 of Object.values(cluster.workers)) {
+          if (worker2 == null ? void 0 : worker2.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
+    __privateAdd(this, _SetupPrometheusForMaster, () => {
+      __privateSet(this, _metricsServer, express());
+      __privateSet(this, _aggregatorRegistry, new AggregatorRegistry());
+      switch (goptions.STSServerType) {
+        case "EXPRESS_TLS":
+          {
+            const options = {
+              key: fs.readFileSync(this.options.httpsServerKeyPath),
+              cert: fs.readFileSync(this.options.httpsServerCertificatePath)
+            };
+            __privateSet(this, _httpServer, createServer$1(options, __privateGet(this, _metricsServer)));
+          }
+          break;
+        case "EXPRESS": {
+          __privateSet(this, _httpServer, createServer(__privateGet(this, _metricsServer)));
+        }
+      }
+      __privateGet(this, _metricsServer).get("/cluster_metrics", async (req, res) => {
+        try {
+          const metrics = await __privateGet(this, _aggregatorRegistry).clusterMetrics();
+          res.set("Content-Type", __privateGet(this, _aggregatorRegistry).contentType);
+          res.send(metrics);
+        } catch (ex) {
+          res.statusCode = 500;
+          res.send(ex.message);
+        }
+      });
+      try {
+        __privateGet(this, _httpServer).listen(this.options.prometheusClusterPort, () => {
+        }).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) {
+        __privateMethod(this, _MasterProcessBase_instances, LogErrorMessage_fn).call(this, error);
+        throw error;
+      }
+    });
+    __privateAdd(this, _CheckLatency, async () => {
+      const start = process.hrtime();
+      await __privateGet(this, _GetLatency).call(this);
+      __privateGet(this, _LatencyRequestCompleted).call(this, start);
+    });
+    __privateAdd(this, _GetLatency, async () => {
+      let retVal = null;
+      const url = `${this.options.endpoint}:${this.options.port}${this.options.apiRoot}/latency`;
+      try {
+        retVal = await axios(new STSAxiosConfig(url, "get").withDefaultHeaders().withAgentManager(__privateGet(this, _agentManager)).config);
+        if (retVal.status !== 200) {
+          __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.magenta(`Error (MasterProcessBase:#GetLatency): Invalid response from server: [${retVal.status}]`));
+          return null;
+        }
+        return retVal.data.detail;
+      } catch (error) {
+        __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.red(`Error (MasterProcessBase:#GetLatency:catch): [${error}]`));
+        __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.red(`  url: [${url}]`));
+        if (error.response && error.response.data) {
+          __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.red(`  Details: [${JSON.stringify(error.response.data)}]`));
+        }
+      }
+    });
+    __privateAdd(this, _LatencyRequestCompleted, (start) => {
+      let timeInMs = 0;
+      const end = process.hrtime(start);
+      timeInMs = (end[0] * 1e9 + end[1]) / 1e6;
+      timeInMs = parseFloat(timeInMs.toFixed(4));
+      this.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
+        val: timeInMs
+      });
+      this.UpdateInstrument(Gauge.LATENCY_GAUGE, {
+        val: timeInMs
+      });
+    });
+    __publicField(this, "SetupServer", async () => {
+      this.SetupInstrumentation();
+      setTimeout(() => {
+        this.SetupServerEx();
+      }, 100);
+    });
+    __privateAdd(this, __KillWorker, (id, signal, killProcess) => {
+      try {
+        if (cluster.workers && cluster.workers[id]) {
+          const worker = cluster.workers[id];
+          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 = killProcess ? "TerminateAndKill" : "Terminate";
+            try {
+              worker.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;
+      }
+    });
+    __publicField(this, "KillWorker", (id, signal = "SIGTERM", options, killProcess, allowKillAll) => {
+      try {
+        if (allowKillAll || Object.keys(cluster.workers).length > 1) {
+          if (id.localeCompare("0") === 0) {
+            const keys = Object.keys(cluster.workers);
+            for (let i = keys.length - 1; i > 0; i--) {
+              id = keys[i];
+              if (!__privateGet(this, _killWorkers)[id]) {
+                __privateGet(this, _killWorkers)[id] = id;
+                setTimeout(() => {
+                  delete __privateGet(this, _killWorkers)[id];
+                }, 2e3).unref();
+                return __privateGet(this, __KillWorker).call(this, id, signal, killProcess);
+              }
+            }
+            return false;
+          } else {
+            return __privateGet(this, __KillWorker).call(this, 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;
+      }
+    });
+    __publicField(this, "KillWorkers", (signal, keepOne) => {
+      const logPrefix = `MasterProcessBase:KillWorkers():${process.pid}:`;
+      try {
+        this.LogInfoMessage(`${logPrefix} Killing Workers.`);
+        const keepOneAlive = keepOne ? keepOne : false;
+        let skippedFirst = false;
+        const sortedIdList = [];
+        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}]`));
+      }
+    });
+    __privateAdd(this, _UpdateWorkersInstrument, () => {
+      setTimeout(() => {
+        this.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
+          val: __privateGet(this, _workers)
+        });
+      }, 2e3);
+    });
+    __publicField(this, "IncWorkers", () => {
+      __privateWrapper(this, _workers)._++;
+      __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, `  Inc Workers. Total thread count: [${__privateGet(this, _workers)}]`);
+      __privateGet(this, _UpdateWorkersInstrument).call(this);
+    });
+    __publicField(this, "DecWorkers", () => {
+      __privateWrapper(this, _workers)._--;
+      __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, `  Dec Workers. Total thread count: [${__privateGet(this, _workers)}]`);
+      __privateGet(this, _UpdateWorkersInstrument).call(this);
+    });
+    __publicField(this, "AddWorker", (options) => {
+      const workerId = __privateGet(this, _SpawnWorker).call(this, options);
+      __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.yellow(`  Spawned worker with id: [${workerId}]`));
+      if (options) {
+        __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.yellow(`  Options: [${JSON.stringify(options)}]`));
+      }
+      return workerId;
+    });
+    __privateAdd(this, _processIPCCommand, async (iPCMessagePayload) => {
+      var _a, _b, _c;
+      __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.yellow(`  Processing message command: [${iPCMessagePayload.command}]`));
+      switch (iPCMessagePayload.command) {
+        case IPCMessageCommand.AddWorker: {
+          const workerId = this.AddWorker((_a = iPCMessagePayload.requestDetail) == null ? void 0 : _a.options);
+          iPCMessagePayload.responseDetail = {
+            workerId
+          };
+          return iPCMessagePayload;
+        }
+        case IPCMessageCommand.DeleteWorker: {
+          const workerId = (_b = iPCMessagePayload.requestDetail) == null ? void 0 : _b.workerId;
+          const workerKilled = this.KillWorker(workerId, "SIGTERM", (_c = iPCMessagePayload.requestDetail) == null ? void 0 : _c.options, true, false);
+          __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.yellow(`  Killed worker with id: [${workerId}]`));
+          iPCMessagePayload.responseDetail = {
+            workerId,
+            workerKilled
+          };
+          return iPCMessagePayload;
+        }
+        case IPCMessageCommand.GetConfig: {
+          const safeOptions = { ...this.options };
+          delete safeOptions.logger;
+          delete safeOptions.publisherLogger;
+          delete safeOptions.expressServerRouteFactory;
+          iPCMessagePayload.responseDetail = {
+            safeOptions
+          };
+          return iPCMessagePayload;
+        }
+        default: {
+          const errorMessage = `Could not process command: [${iPCMessagePayload.command}].`;
+          __privateMethod(this, _MasterProcessBase_instances, LogDebugMessage_fn).call(this, chalk.red(`  ${errorMessage}`));
+          throw new Error(errorMessage);
+        }
+      }
+    });
+    __privateAdd(this, _SpawnWorker, (spawnWorkerOptions) => {
+      const workerEnv = {};
+      const tempOptions = { ...this.options };
+      delete tempOptions.logger;
+      delete tempOptions.publisherLogger;
+      workerEnv["STS_GSD_SII"] = JSON.stringify(tempOptions);
+      if (spawnWorkerOptions) {
+        workerEnv["STS_GSD_OPTIONS"] = JSON.stringify(spawnWorkerOptions);
+      }
+      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);
+        if (payload.requestResponse) {
+          const iPCMessagePayload = payload;
+          const response = await this.ProcessIPCCommand(iPCMessagePayload);
+          worker.send(response);
+        } else {
+          __privateMethod(this, _MasterProcessBase_instances, WorkerMessageEvent_fn).call(this, 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;
+    });
+    __publicField(this, "SetupServerEx", async () => {
+      this.ProcessStartup();
+      this.LogInfoMessage(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
+      this.LogSystemTelemetry();
+      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) {
+        __privateGet(this, _SetupPrometheusForMaster).call(this);
+      }
+      const numCPUs = await this.GetNumCPUs();
+      for (let i = 0; i < numCPUs; i++) {
+        __privateGet(this, _SpawnWorker).call(this);
+      }
+      __privateGet(this, _InitCluster).call(this);
+      cluster.on("listening", (worker, address) => {
+        this.emit("clusterListening", worker, address);
+        this.LogInfoMessage(`Worker process ${worker.process.pid} is listening at address: ${JSON.stringify(address)}`);
+      });
+      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`));
+            __privateGet(this, _SpawnWorker).call(this);
+          }
+        }
+      });
+      const TerminateLatency = () => {
+        if (__privateGet(this, _checkLatency)) {
+          clearInterval(__privateGet(this, _checkLatency));
+          __privateSet(this, _checkLatency, null);
+        }
+      };
+      const TerminateHTTPServer = async () => {
+        if (__privateGet(this, _httpServer) !== null) {
+          const logPrefix = `ServerProcessBase:TerminateHTTPServer():${process.pid}:`;
+          this.LogInfoMessage(`${logPrefix} Closing httpServer.`);
+          await __privateGet(this, _httpServer).close();
+          __privateSet(this, _httpServer, null);
+        }
+      };
+      const Terminate = async (signal) => {
+        const logPrefix = `MasterProcessBase:Terminate():${process.pid}:`;
+        if (__privateGet(this, _shuttingDown) === false) {
+          __privateSet(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.`);
+          await TerminateHTTPServer();
+          this.KillWorkers(signal);
+          await this.TerminateDatabase();
+          this.TerminateInstrumentController();
+          await Sleep(1e3);
+          this.ProcessExit(__privateGet(this, _childProcessExitTime) + __privateGet(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) {
+        __privateSet(this, _checkLatency, setInterval(() => {
+          __privateGet(this, _CheckLatency).call(this);
+        }, 1e3).unref());
+      }
+      this.MasterStarted();
+      this.LogInfoMessage(chalk.green(`Master process:${process.pid} started`));
+    });
+    __publicField(this, "BroadcastDataToWorkers", (command, data) => {
+      try {
+        for (const id in cluster.workers) {
+          try {
+            cluster.workers[id].process.send({ command, data });
+          } catch (error) {
+          }
+        }
+      } catch (error) {
+      }
+    });
+    __privateSet(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
+      }
+    }));
+  }
+  CollectAdditionalTelemetry() {
+    si.get(__privateGet(this, _siValueObject)).then((data) => {
+      this.UpdateInstrument(Gauge.CPU_SYSTEM_LOAD_GAUGE, {
+        val: data.currentLoad.currentLoad
+      });
+    });
+  }
+  GetAdditionalInstruments() {
+    return [
+      [Gauge.CPU_SYSTEM_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
+        interval: goptions.instrumentationObservationInterval,
+        sampleSize: goptions.instrumentationTimeWindow
+      }]
+    ];
+  }
+  /**
+  * Note: msg removed from signature but will be passed at run-time.
+  * @param {*} msg 
+  */
+  WorkerMessageEvent(workerId, msg) {
+    return null;
+  }
+  async ProcessIPCCommand(iPCMessagePayload) {
+    return __privateGet(this, _processIPCCommand).call(this, iPCMessagePayload);
+  }
+  MasterStarted() {
+    const transport = new STSTransportLoggerWinston({
+      stsApp: this
+    });
+    setTimeout(() => {
+      this.options.logger.add(transport);
+    }, 0);
+  }
+  get shuttingDown() {
+    return __privateGet(this, _shuttingDown);
+  }
+  /*
+      #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;
+      }
+      */
+}
+_masterProcessExitTime = new WeakMap();
+_childProcessExitTime = new WeakMap();
+_siValueObject = new WeakMap();
+_httpServer = new WeakMap();
+_metricsServer = new WeakMap();
+_aggregatorRegistry = new WeakMap();
+_checkLatency = new WeakMap();
+_killWorkers = new WeakMap();
+_workers = new WeakMap();
+_shuttingDown = new WeakMap();
+_agentManager = new WeakMap();
+_MasterProcessBase_instances = new WeakSet();
+LogErrorMessage_fn = function(message) {
+  this.options.logger.error(message);
+};
+LogDebugMessage_fn = function(message) {
+  this.options.logger.debug(message);
+};
+WorkerMessageEvent_fn = function(workerId, msg) {
+  if (msg.command) {
+    this.WorkerMessageEvent(workerId, msg);
+  }
+};
+_InitCluster = new WeakMap();
+_SetupPrometheusForMaster = new WeakMap();
+_CheckLatency = new WeakMap();
+_GetLatency = new WeakMap();
+_LatencyRequestCompleted = new WeakMap();
+__KillWorker = new WeakMap();
+_UpdateWorkersInstrument = new WeakMap();
+_processIPCCommand = new WeakMap();
+_SpawnWorker = new WeakMap();
+var ServerNetworkMiddlewareEventName = /* @__PURE__ */ ((ServerNetworkMiddlewareEventName2) => {
+  ServerNetworkMiddlewareEventName2["UpdateInstrument_SERVER_NET_VAL"] = "UpdateInstrument_SERVER_NET_VAL";
+  return ServerNetworkMiddlewareEventName2;
+})(ServerNetworkMiddlewareEventName || {});
+class ServerNetworkMiddleware extends STSOptionsBase {
+  constructor(options) {
+    super(options);
+    __privateAdd(this, _ServerNetworkMiddleware_instances);
+    __privateAdd(this, _tinyEmitter, new TinyEmitter());
+    __privateAdd(this, _socketCollection, {});
+    __privateAdd(this, _id, "");
+    __publicField(this, "GetSocketRecord", (socket) => {
+      for (const [, socketRecord] of Object.entries(__privateGet(this, _socketCollection))) {
+        if (socketRecord.socket === socket) {
+          return socketRecord;
+        }
+      }
+      return null;
+    });
+    __publicField(this, "UpdateNetworkStats", (workingSocketRecord, eventName, req) => {
+      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;
+      const workingSocketEventRecord = { ...workingSocketRecord };
+      delete workingSocketEventRecord.socket;
+      __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Sending event: [${JSON.stringify(workingSocketEventRecord)}]`));
+      __privateGet(this, _tinyEmitter).emit("UpdateInstrument_SERVER_NET_VAL", workingSocketEventRecord);
+      workingSocketRecord.lastBytesRead = workingSocketRecord.currentBytesRead;
+      workingSocketRecord.lastBytesWritten = workingSocketRecord.currentBytesWritten;
+    });
+    __privateAdd(this, _GetRequestContentSize, (req) => {
+      try {
+        let contentLength = 0;
+        if (req["_contentLength"]) {
+          contentLength = req["_contentLength"];
+        } else {
+          if (req.headers["content-length"]) {
+            contentLength = parseInt(req.headers["content-length"]);
+          }
+        }
+        return contentLength;
+      } catch (error) {
+        __privateMethod(this, _ServerNetworkMiddleware_instances, LogErrorMessage_fn2).call(this, chalk.red(`ServerNetworkMiddleware:#GetRequestContentSize(): Error: [${error}]`));
+        return 0;
+      }
+    });
+    __publicField(this, "Middleware", (req, res, next) => {
+      let workingSocketRecord = null;
+      workingSocketRecord = this.GetSocketRecord(req.socket);
+      if (!workingSocketRecord) {
+        __privateSet(this, _id, v4());
+        workingSocketRecord = {
+          id: `${this.options.name}_${__privateGet(this, _id).toString()}`,
+          socket: req.socket,
+          currentBytesRead: 0,
+          currentBytesWritten: 0,
+          lastBytesRead: 0,
+          lastBytesWritten: 0,
+          requestBytesRead: 0,
+          requestBytesWritten: 0,
+          originalUrl: req.originalUrl,
+          eventName: ""
+        };
+        __privateGet(this, _socketCollection)[workingSocketRecord.id] = workingSocketRecord;
+        __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Adding new socket to recordset: ID: [${workingSocketRecord.id}], originalUrl: [${workingSocketRecord.originalUrl}]`));
+        workingSocketRecord.socket.on("data", () => {
+          const socketRecord = this.GetSocketRecord(workingSocketRecord.socket);
+          if (socketRecord) {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Socket data event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+            this.UpdateNetworkStats(socketRecord, "socket_data", req);
+          } else {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.magenta(`Socket data event: Could not find socket within recordset`));
+          }
+        });
+        workingSocketRecord.socket.on("close", () => {
+          const socketRecord = this.GetSocketRecord(workingSocketRecord.socket);
+          if (socketRecord) {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Socket close event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+            this.UpdateNetworkStats(socketRecord, "socket_close", req);
+            delete __privateGet(this, _socketCollection)[socketRecord.id];
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Socket removed from recordset: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+          } else {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.magenta(`Socket close event: Could not find socket within recordset`));
+          }
+        });
+        workingSocketRecord.socket.on("end", () => {
+          const socketRecord = this.GetSocketRecord(workingSocketRecord.socket);
+          if (socketRecord) {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Socket end event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+            this.UpdateNetworkStats(socketRecord, "socket_end", req);
+          } else {
+            __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.magenta(`Socket end event: Could not find socket within recordset`));
+          }
+        });
+      }
+      onHeaders(res, () => {
+        let contentLength = 0;
+        if (res["_contentLength"]) {
+          contentLength = res["_contentLength"];
+        } else {
+          if (res.hasHeader("content-length")) {
+            contentLength = parseInt(res.getHeader("content-length"));
+          }
+        }
+        res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+        const headerLength = JSON.stringify(res.getHeaders()).length;
+        const totalSize = contentLength + headerLength;
+        __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.white.bgBlue(`contentLength: [${contentLength}], headerLength: [${headerLength}], total Size: [${totalSize}]`));
+      });
+      req.on("end", () => {
+        const socketRecord = this.GetSocketRecord(req.socket);
+        if (socketRecord) {
+          __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Request end event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+          this.UpdateNetworkStats(socketRecord, "req_end", req);
+        } else {
+          __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.magenta(`Request end event: Could not find socket within recordset`));
+        }
+      });
+      req.on("close", () => {
+        const socketRecord = this.GetSocketRecord(req.socket);
+        if (socketRecord) {
+          __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.gray(`Request close event: ID: [${socketRecord.id}], originalUrl: [${socketRecord.originalUrl}]`));
+          this.UpdateNetworkStats(socketRecord, "req_close", req);
+        } else {
+          __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.magenta(`Request close event: Could not find socket within recordset`));
+        }
+      });
+      const inHeadersLength = JSON.stringify(req.headers).length;
+      const inContentLength = __privateGet(this, _GetRequestContentSize).call(this, req);
+      const inTotal = inHeadersLength + inContentLength;
+      __privateMethod(this, _ServerNetworkMiddleware_instances, LogSillyMessage_fn).call(this, chalk.white.bgGray(`inHeadersLength: [${inHeadersLength}], inContentLength: [${inContentLength}], inTotal: [${inTotal}]`));
+      this.UpdateNetworkStats(workingSocketRecord, "middleware", req);
+      next();
+    });
+  }
+  on(eventName, callBackFn) {
+    __privateGet(this, _tinyEmitter).on(eventName, callBackFn);
+  }
+}
+_tinyEmitter = new WeakMap();
+_socketCollection = new WeakMap();
+_id = new WeakMap();
+_ServerNetworkMiddleware_instances = new WeakSet();
+LogSillyMessage_fn = function(message) {
+  var _a;
+  (_a = this.options) == null ? void 0 : _a.logger.silly(message);
+};
+LogErrorMessage_fn2 = function(message) {
+  var _a;
+  (_a = this.options) == null ? void 0 : _a.logger.error(message);
+};
+_GetRequestContentSize = new WeakMap();
+class STSExpressServer {
+  constructor(options, stsApp) {
+    __privateAdd(this, _app);
+    var _a;
+    const requestLoggerMiddleware = new RequestLoggerMiddleware({
+      ignoresocketio: goptions.ignoresocketio
+    });
+    const serverNetworkMiddleware = new ServerNetworkMiddleware({
+      name: stsApp.options.serviceName,
+      outputDebug: false,
+      logger: (_a = stsApp.options) == null ? void 0 : _a.logger
+    });
+    serverNetworkMiddleware.on(ServerNetworkMiddlewareEventName.UpdateInstrument_SERVER_NET_VAL, (data) => {
+      stsApp.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
+        Inc: data.requestBytesRead
+      });
+      stsApp.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
+        Inc: data.requestBytesWritten
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_AR_INC, () => {
+      stsApp.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+        Inc: 1
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_AR_DEC, () => {
+      stsApp.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+        Dec: 1
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_DH_VAL, (timeInMs) => {
+      stsApp.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
+        val: timeInMs
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_D_VAL, (timeInMs) => {
+      stsApp.UpdateInstrument(Gauge.DURATION_GAUGE, {
+        val: timeInMs
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_RC_INC, () => {
+      stsApp.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
+        Inc: 1
+      });
+    });
+    requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_V_INC, () => {
+      if (stsApp.InstrumentExists(Gauge.VELOCITY_GAUGE)) {
+        stsApp.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
+          Inc: 1
+        });
+      }
+    });
+    const app = express();
+    __privateSet(this, _app, app);
+    const corsConfig = {
+      credentials: true,
+      origin: true
+    };
+    app.use(cors(corsConfig));
+    app.use(cookieParser());
+    app.use(express.urlencoded({ extended: false, limit: goptions.maxPayloadSize }));
+    app.use(express.json({ limit: goptions.maxPayloadSize }));
+    if (options.expressServerRouteStaticFactory) {
+      options.expressServerRouteStaticFactory(app, stsApp);
+    }
+    app.use(requestLoggerMiddleware.Middleware.bind(requestLoggerMiddleware));
+    app.use(serverNetworkMiddleware.Middleware.bind(serverNetworkMiddleware));
+    if (options.expressServerRouteFactory) {
+      options.expressServerRouteFactory(app, stsApp);
+    }
+    app.use(function(err, req, res, next) {
+      if (err) {
+        res.status(err.status).send(err);
+      } else {
+        next();
+      }
+    });
+  }
+  get App() {
+    return __privateGet(this, _app);
+  }
+}
+_app = new WeakMap();
+class ServerProcessBase extends ProcessBase {
+  constructor(options) {
+    super(options);
+    __privateAdd(this, _masterProcessExitTime2, goptions.masterProcessExitTime);
+    __privateAdd(this, _io, null);
+    __privateAdd(this, _redisClient, null);
+    __privateAdd(this, _httpServer2, null);
+    __privateAdd(this, _expressServer, null);
+    __privateAdd(this, _sockets, []);
+    __privateAdd(this, _shuttingDown2, false);
+    // Setup server to Prometheus scrapes:
+    __privateAdd(this, _SetupPrometheusEndPoints, (expressServer) => {
+      new AggregatorRegistry();
+      const prefix = "sts_";
+      collectDefaultMetrics({
+        labels: { NODE_APP_INSTANCE: process.pid },
+        prefix
+      });
+      const c = new Counter({
+        name: "sts_test_counter",
+        help: "Example of a counter",
+        labelNames: ["code"]
+      });
+      setInterval(() => {
+        c.inc({ code: 200 });
+      }, 1e3).unref();
+      setInterval(() => {
+        c.inc({ code: 400 });
+        c.inc({ code: "worker_" + process.pid });
+      }, 500).unref();
+      expressServer.get("/metrics", async (req, res) => {
+        try {
+          res.set("Content-Type", register.contentType);
+          res.end(await register.metrics());
+        } catch (ex) {
+          res.status(500).end(ex);
+        }
+      });
+      expressServer.get("/metrics/counter", async (req, res) => {
+        try {
+          res.set("Content-Type", register.contentType);
+          res.end(await register.getSingleMetricAsString("test_counter"));
+        } catch (ex) {
+          res.status(500).end(ex);
+        }
+      });
+    });
+    __privateAdd(this, _SetupTLSServer, async (socket) => {
+      this.LogInfoMessage("CONNECTED: " + socket.remoteAddress + ":" + socket.remotePort + " " + process.pid);
+      __privateGet(this, _sockets).push(socket);
+      socket.on("close", (data) => {
+        const index = __privateGet(this, _sockets).findIndex(function(o) {
+          return o.remoteAddress === socket.remoteAddress && o.remotePort === socket.remotePort;
+        });
+        if (index !== -1) __privateGet(this, _sockets).splice(index, 1);
+        this.LogInfoMessage("CLOSED: " + socket.remoteAddress + " " + socket.remotePort + " " + process.pid);
+      });
+      socket.on("data", (data) => {
+        this.LogInfoMessage("DATA " + socket.remoteAddress + ": " + socket.remotePort + ": " + data);
+        socket.write(socket.remoteAddress + ":" + socket.remotePort + " said " + data + "\n");
+      });
+    });
+    __privateAdd(this, _SetupRPCServer, async (socket) => {
+      this.LogInfoMessage("CONNECTED: " + socket.remoteAddress + ":" + socket.remotePort + " " + process.pid);
+      socket.on("close", (data) => {
+        this.LogInfoMessage("CLOSED: " + socket.remoteAddress + " " + socket.remotePort + " " + process.pid);
+      });
+      socket.on("data", (data) => {
+        this.LogInfoMessage("DATA " + socket.remoteAddress + ": " + data);
+      });
+    });
+    __privateAdd(this, _SetupWSSServer, async () => {
+      const options = {
+        transports: ["websocket"]
+        // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
+        // The default path is /socket.io
+        // This can be changed with the path option as shown below
+        //,path: '/zzz'
+      };
+      __privateSet(this, _io, new Server(__privateGet(this, _httpServer2), options));
+      if (this.options.useSocketIoRedisAdaptor) {
+        this.LogInfoMessage(`Using Redis for socket.io cluster management (worker)`);
+        if (this.options.socketIoRedisAdaptorUrl) {
+          this.LogInfoMessage(`Redis url: [${this.options.socketIoRedisAdaptorUrl}]`);
+          __privateSet(this, _redisClient, createClient({ url: this.options.socketIoRedisAdaptorUrl }));
+        } else {
+          this.LogInfoMessage(`Redis url: [localhost]`);
+          __privateSet(this, _redisClient, createClient());
+        }
+        await __privateGet(this, _redisClient).connect();
+        __privateGet(this, _io).adapter(createAdapter(__privateGet(this, _redisClient)));
+        this.LogInfoMessage(`Redis successfully connected.`);
+      } else {
+        if (this.options.clusterMode) {
+          __privateGet(this, _io).adapter(createAdapter$1());
+          this.LogInfoMessage(`Using nodejs cluster mode for socket.io cluster management`);
+        } else {
+          this.LogInfoMessage(`Not using any adaptors for socket.io cluster management.}`);
+        }
+      }
+      __privateGet(this, _io).engine.on("connection_error", (err) => {
+        this.LogInfoMessage(err.req);
+        this.LogInfoMessage(err.code);
+        this.LogInfoMessage(err.message);
+        this.LogInfoMessage(err.context);
+      });
+    });
+    __privateAdd(this, _GetTLSOptions, () => {
+      return {
+        key: fs.readFileSync(this.options.httpsServerKeyPath),
+        cert: fs.readFileSync(this.options.httpsServerCertificatePath)
+      };
+    });
+    __privateAdd(this, _SetupExpressServer, async (useTls) => {
+      if (useTls) {
+        __privateSet(this, _httpServer2, createServer$1(__privateGet(this, _GetTLSOptions).call(this), __privateGet(this, _expressServer).App));
+      } else {
+        __privateSet(this, _httpServer2, createServer(__privateGet(this, _expressServer).App));
+      }
+      if (this.options.prometheusSupport === true) {
+        __privateGet(this, _SetupPrometheusEndPoints).call(this, __privateGet(this, _expressServer).App);
+      }
+      if (this.options.wssServer === true) {
+        await __privateGet(this, _SetupWSSServer).call(this);
+      }
+      __privateGet(this, _httpServer2).listen(this.options.listenPort, () => {
+      }).on("listening", () => {
+        this.LogInfoMessage(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+      });
+    });
+    __privateAdd(this, _SetupTCPRawServer, async () => {
+      __privateSet(this, _httpServer2, tls.createServer(__privateGet(this, _GetTLSOptions).call(this), __privateGet(this, _SetupTLSServer)));
+      __privateGet(this, _httpServer2).listen(this.options.listenPort, "stscore.stsmda.org", () => {
+        this.LogInfoMessage("TCP Server is running on port " + this.options.listenPort + ".");
+      }).on("listening", () => {
+        this.LogInfoMessage(`TCP live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+      });
+    });
+    __privateAdd(this, _SetupJSONRPCServer, async () => {
+      const jaysonServer = new jayson.server();
+      jaysonServer.method("add", function(args, callback) {
+        callback(null, args[0] + args[1]);
+      });
+      __privateSet(this, _httpServer2, jaysonServer.tls(__privateGet(this, _GetTLSOptions).call(this)));
+      __privateGet(this, _httpServer2).on("secureConnection", __privateGet(this, _SetupRPCServer));
+      __privateGet(this, _httpServer2).listen(this.options.listenPort, "stscore.stsmda.org", () => {
+        this.LogInfoMessage("JSON RPC 2.0 Server is running on port " + this.options.listenPort + ".");
+      }).on("listening", () => {
+        this.LogInfoMessage(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+      });
+    });
+    __publicField(this, "TerminateSocketIO", async () => {
+      var _a;
+      if (this.options.wssServer === true && __privateGet(this, _io) !== null) {
+        const logPrefix = `ServerProcessBase:TerminateSockets():${process.pid}:`;
+        this.LogInfoMessage(`${logPrefix} Disconnect SocketIO Sockets.`);
+        await Sleep(250);
+        await ((_a = __privateGet(this, _io)) == null ? void 0 : _a.of("/").adapter.close());
+        if (this.socketIoServerHelper !== null) {
+          await this.socketIoServerHelper.CloseAdaptors();
+          await Sleep(50);
+          if (__privateGet(this, _redisClient)) {
+            __privateGet(this, _redisClient).disconnect();
+            await Sleep(50);
+          }
+          this.LogInfoMessage(`${logPrefix} this.socketIoServerHelper.DisconnectSockets()`);
+          await this.socketIoServerHelper.DisconnectSockets();
+        } else {
+          this.LogInfoMessage(`${logPrefix} this.#io.disconnectSockets()`);
+          if (__privateGet(this, _redisClient)) {
+            __privateGet(this, _redisClient).disconnect();
+            await Sleep(50);
+          }
+          __privateGet(this, _io).disconnectSockets();
+        }
+        this.socketIoServerHelper = null;
+        __privateSet(this, _io, null);
+      }
+    });
+    __publicField(this, "TerminateHTTPServer", async () => {
+      const logPrefix = `ServerProcessBase:TerminateHTTPServer():${process.pid}:`;
+      if (__privateGet(this, _httpServer2) !== null) {
+        if (goptions.STSServerType.localeCompare("TCPRAW_TLS") === 0) {
+          __privateGet(this, _sockets).forEach((socket, index, array) => {
+            this.LogInfoMessage(chalk.yellow(`${logPrefix} TCP Socket destroy, remote address: [${socket.remoteAddress}], remote port: [${socket.remotePort}]`));
+            socket.destroy();
+          });
+        }
+        this.LogInfoMessage(`${logPrefix} Closing httpServer.`);
+        await __privateGet(this, _httpServer2).close();
+        __privateSet(this, _httpServer2, null);
+      }
+    });
+    // Terminate in order;
+    // forked worker threads (send signal)
+    // De-Register service
+    // systeminformation observers
+    // instrument timers (gauge etc.)
+    // publisher
+    // terminate UI (if loaded)
+    __publicField(this, "Terminate", async (clusterPerformExit, signal) => {
+      const logPrefix = `ServerProcessBase:Terminate():${process.pid}:`;
+      if (__privateGet(this, _shuttingDown2) === false) {
+        __privateSet(this, _shuttingDown2, true);
+        if (signal) {
+          this.LogInfoMessage(this.GetSignalColour(signal)(`${logPrefix} Received signal: ${signal}`));
+        } else {
+          this.LogInfoMessage(this.GetSignalColour(null)(`${logPrefix} Received Terminate without signal.`));
+        }
+        await this.ProcessTerminate();
+        this.TerminateUIController();
+        await this.TerminateSocketIO();
+        await this.TerminateHTTPServer();
+        await this.TerminateDatabase();
+        if (this.options.clusterMode) {
+          this.LogInfoMessage(`${logPrefix} clusterPerformExit value: [${clusterPerformExit}]`);
+          if (clusterPerformExit) {
+            this.LogInfoMessage(`${logPrefix} Process will self terminate with process.exit(0).`);
+          } else {
+            this.LogInfoMessage(`${logPrefix} Child process will not self terminate. Terminate will be handled by master process.`);
+          }
+        }
+        this.TerminateInstrumentController();
+        await Sleep(1e3);
+        if (this.options.clusterMode === true) {
+          if (clusterPerformExit === true) {
+            setTimeout(() => {
+              process.exit(0);
+            }, 0);
+          }
+        } else {
+          this.ProcessExit(__privateGet(this, _masterProcessExitTime2));
+        }
+      } else {
+        this.LogInfoMessage(`${logPrefix} Process already terminating.`);
+      }
+    });
+    __publicField(this, "SetupSTSServer", async () => {
+      switch (goptions.STSServerType) {
+        case "EXPRESS":
+          await __privateGet(this, _SetupExpressServer).call(this, false);
+          break;
+        case "EXPRESS_TLS":
+          await __privateGet(this, _SetupExpressServer).call(this, true);
+          break;
+        case "TCPRAW_TLS":
+          await __privateGet(this, _SetupTCPRawServer).call(this);
+          break;
+        case "JSONRPC2_TLS":
+          await __privateGet(this, _SetupJSONRPCServer).call(this);
+          break;
+      }
+    });
+  }
+  get httpServer() {
+    return __privateGet(this, _httpServer2);
+  }
+  get io() {
+    return __privateGet(this, _io);
+  }
+  get expressServer() {
+    return __privateGet(this, _expressServer);
+  }
+  set expressServer(val) {
+    __privateSet(this, _expressServer, val);
+  }
+  get shuttingDown() {
+    return __privateGet(this, _shuttingDown2);
+  }
+  async SetupServer() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.SetupInstrumentation();
+        setTimeout(async () => {
+          try {
+            await this.SetupServerEx();
+            resolve(true);
+          } catch (error) {
+            reject(error);
+          }
+        }, 100);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  ProcessStarted() {
+    const transport = new STSTransportLoggerWinston({
+      stsApp: this
+    });
+    setTimeout(() => {
+      this.options.logger.add(transport);
+    }, 0);
+  }
+  async SetupServerEx() {
+    this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Main Process:${process.pid} Starting ...`));
+    this.ProcessStartup();
+    if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
+      this.expressServer = new STSExpressServer(this.options, this);
+    }
+    this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
+    process.on("SIGTERM", async () => {
+      this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): SIGTERM signal received for worker: ${process.pid}`);
+      await this.Terminate(true, true);
+    });
+    process.on("SIGINT", async () => {
+      this.LogInfoMessage(`ServerProcessBase:SetupServerEx(): SIGINT signal received for worker: ${process.pid}`);
+      await this.Terminate(true, true);
+    });
+    process.on("exit", (code) => {
+      if (code === 0) {
+        this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Process: ${process.pid} terminated gracefully with code: ${code}`));
+      } else {
+        this.LogInfoMessage(chalk.red(`ServerProcessBase:SetupServerEx(): Process: ${process.pid} terminated with code: ${code}`));
+      }
+    });
+    await this.SetupSTSServer();
+    this.ProcessStarted();
+    this.LogInfoMessage(chalk.green(`ServerProcessBase:SetupServerEx(): Main Process:${process.pid} Started`));
+    return true;
+  }
+}
+_masterProcessExitTime2 = new WeakMap();
+_io = new WeakMap();
+_redisClient = new WeakMap();
+_httpServer2 = new WeakMap();
+_expressServer = new WeakMap();
+_sockets = new WeakMap();
+_shuttingDown2 = new WeakMap();
+_SetupPrometheusEndPoints = new WeakMap();
+_SetupTLSServer = new WeakMap();
+_SetupRPCServer = new WeakMap();
+_SetupWSSServer = new WeakMap();
+_GetTLSOptions = new WeakMap();
+_SetupExpressServer = new WeakMap();
+_SetupTCPRawServer = new WeakMap();
+_SetupJSONRPCServer = new WeakMap();
+class SingleProcessBase extends ServerProcessBase {
+  /**
+  * 
+  * @param {SingleProcessBaseOptions} options 
+  */
+  constructor(options) {
+    super(options);
+    __publicField(this, "SetupServerEx", async () => {
+      await super.SetupServerEx();
+      this.LogSystemTelemetry();
+      return true;
+    });
+  }
+  CollectAdditionalTelemetry() {
+    const siValueObject = {
+      currentLoad: "currentLoad"
+    };
+    si.get(siValueObject).then((data) => {
+      this.UpdateInstrument(Gauge.CPU_SYSTEM_LOAD_GAUGE, {
+        val: data.currentLoad.currentLoad
+      });
+    });
+  }
+  GetAdditionalInstruments() {
+    return [
+      [Gauge.CPU_SYSTEM_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
+        interval: goptions.instrumentationObservationInterval,
+        sampleSize: goptions.instrumentationTimeWindow
+      }]
+    ];
+  }
+  /**
+  * 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. Null for no capability.
+  */
+  GetUIController() {
+    return null;
+  }
+  async TerminateApplication() {
+    await this.Terminate(false, "SIGINT");
+  }
+}
+class WorkerProcessBase extends ServerProcessBase {
+  constructor(options) {
+    super(options);
+    __privateAdd(this, _inFlightMessage, {});
+    __privateAdd(this, _requestResponseMessageTimeout, 5e3);
+    //@@ config
+    __privateAdd(this, _pingTimeout, null);
+    __privateAdd(this, _SendMessageToParentProcess, (message) => {
+      return new Promise((resolve, reject) => {
+        if (__privateGet(this, _inFlightMessage)[message.id]) {
+          reject(`Message with id: [${message.id}] already exists within the Request/Response record structure`);
+        } else {
+          __privateGet(this, _inFlightMessage)[message.id] = {
+            iPCMessagePayload: { ...message },
+            cb: () => {
+              const detail = __privateGet(this, _inFlightMessage)[message.id].iPCMessagePayload.responseDetail;
+              clearTimeout(__privateGet(this, _inFlightMessage)[message.id].timeout);
+              setTimeout(() => {
+                delete __privateGet(this, _inFlightMessage)[message.id];
+              }, 0).unref();
+              resolve(detail);
+            },
+            timeout: setTimeout(() => {
+              setTimeout(() => {
+                delete __privateGet(this, _inFlightMessage)[message.id];
+              }, 0).unref();
+              reject("Did not receive response form parent process.");
+            }, __privateGet(this, _requestResponseMessageTimeout))
+            // max message timeout allowed
+          };
+          process.send(message);
+        }
+      });
+    });
+    __publicField(this, "AddWorker", async (options) => {
+      const workerResponse = await __privateGet(this, _SendMessageToParentProcess).call(this, {
+        requestResponse: true,
+        id: v4(),
+        command: IPCMessageCommand.AddWorker,
+        requestDetail: {
+          options
+        }
+      });
+      return workerResponse.workerId;
+    });
+    __publicField(this, "DeleteWorker", async (workerId, options) => {
+      const workerResponse = await __privateGet(this, _SendMessageToParentProcess).call(this, {
+        requestResponse: true,
+        id: v4(),
+        command: IPCMessageCommand.DeleteWorker,
+        requestDetail: {
+          options,
+          workerId
+        }
+      });
+      return workerResponse;
+    });
+    __publicField(this, "GetMasterProcessOptions", async () => {
+      const parentResponse = await __privateGet(this, _SendMessageToParentProcess).call(this, {
+        requestResponse: true,
+        id: v4(),
+        command: IPCMessageCommand.GetConfig,
+        requestDetail: {}
+      });
+      return parentResponse;
+    });
+    __publicField(this, "GetNumCPUs", async () => {
+      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;
+    });
+    __publicField(this, "GetSystemTelemetry", async () => {
+      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 = [];
+      sysinfo.dockerContainers.forEach((dc) => {
+        const dcs = promArray.push(si.dockerContainerStats(dc.id));
+        console.log(dcs);
+      });
+      const dockerContainerStats = await Promise.all(promArray);
+      const sysInfo = {
+        serviceInstanceId: this.options.serviceInstanceId,
+        serviceProcessContext: this.options.serviceProcessContext,
+        hostname,
+        numCPUs,
+        hostaddr,
+        system: sysinfo.system,
+        osInfo: sysinfo.osInfo,
+        cpu: sysinfo.cpu,
+        mem: sysinfo.mem,
+        dockerInfo: sysinfo.dockerInfo,
+        dockerContainers: sysinfo.dockerContainers,
+        dockerContainerStats
+      };
+      return sysInfo;
+    });
+    __publicField(this, "SetupServerEx", async () => {
+      await super.SetupServerEx();
+      process.on("message", async (msg) => {
+        if (msg.requestResponse) {
+          const iPCMessagePayload = msg;
+          if (iPCMessagePayload.id) {
+            if (__privateGet(this, _inFlightMessage)[iPCMessagePayload.id]) {
+              const responseMessage = __privateGet(this, _inFlightMessage)[iPCMessagePayload.id];
+              responseMessage.iPCMessagePayload.responseDetail = { ...iPCMessagePayload.responseDetail };
+              responseMessage.cb();
+            } else {
+              throw new Error(`Could not find Request/Response message with id: [${iPCMessagePayload.id}]`);
+            }
+          } else {
+            throw new Error(`Message does not have id attribute. [${JSON.stringify(iPCMessagePayload)}]`);
+          }
+          return;
+        }
+        if (msg.command) {
+          switch (msg.command) {
+            case "Terminate":
+              this.LogInfoMessage(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
+              await this.Terminate(true, false);
+              break;
+            case "TerminateAndKill":
+              this.LogInfoMessage(chalk.grey(`Received ` + chalk.bold.italic(`Terminate`) + ` message from master thread`));
+              await this.Terminate(true, true);
+              break;
+            case "Message":
+              this.ReceivedMessageFromMaster(msg.data);
+              break;
+          }
+        }
+      });
+      return true;
+    });
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+  ReceivedMessageFromMaster(msg) {
+  }
+  CollectAdditionalTelemetry() {
+    this.httpServer.getConnections((error, count) => {
+      this.UpdateInstrument(Gauge.CONNECTION_COUNT_GAUGE, {
+        val: count
+      });
+    });
+  }
+  ProcessTerminate() {
+    if (__privateGet(this, _pingTimeout)) {
+      clearTimeout(__privateGet(this, _pingTimeout));
+    }
+    return super.ProcessTerminate();
+  }
+}
+_inFlightMessage = new WeakMap();
+_requestResponseMessageTimeout = new WeakMap();
+_pingTimeout = new WeakMap();
+_SendMessageToParentProcess = new WeakMap();
+class STSControllerBase {
+  constructor(stsApp) {
+    __privateAdd(this, _stsApp);
+    __privateSet(this, _stsApp, stsApp);
+  }
+  get stsApp() {
+    return __privateGet(this, _stsApp);
+  }
+}
+_stsApp = new WeakMap();
+class STSLatencyController extends STSControllerBase {
+  constructor(stsApp) {
+    super(stsApp);
+  }
+  // curl http://localhost:3000/api/v1/latency/latency
+  async stslatency(req, res) {
+    try {
+      const retVal = {
+        data: `Ping Completed At: ${Date.now()}`,
+        pid: process.pid,
+        ppid: process.ppid
+      };
+      return res.status(StatusCodes.OK).send(retVal);
+    } catch (error) {
+      this.stsApp.LogErrorMessage(error);
+      return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send({ status: StatusCodes.INTERNAL_SERVER_ERROR, error: "Operation was not successful", detail: error });
+    }
+  }
+}
+class STSRouterBase {
+  constructor(stsApp) {
+    __privateAdd(this, _router);
+    __privateAdd(this, _stsApp2);
+    __privateSet(this, _stsApp2, stsApp);
+    __privateSet(this, _router, Router());
+  }
+  get router() {
+    return __privateGet(this, _router);
+  }
+  get stsApp() {
+    return __privateGet(this, _stsApp2);
+  }
+}
+_router = new WeakMap();
+_stsApp2 = new WeakMap();
+class STSLatencyRoute extends STSRouterBase {
+  constructor(stsApp) {
+    super(stsApp);
+    const latencyController = new STSLatencyController(stsApp);
+    const { stslatency } = latencyController;
+    this.router.get("/latency", stslatency.bind(latencyController));
+  }
+}
+class PublishTransportUtils {
+  static GetServiceContext(nid) {
+    if (nid === ModelDelimeter.ROOT) {
+      return { root: ModelDelimeter.ROOT };
+    }
+    const context = { nid };
+    const idsplit = nid.split(ModelDelimeter.SEPERATOR);
+    const serviceId = idsplit[0];
+    const serviceInstanceId = idsplit[1].split(ModelDelimeter.NID_SEPERATOR)[0];
+    const serviceInstanceProcessId = idsplit[1].split(ModelDelimeter.NID_SEPERATOR)[1];
+    const serviceIdSplit = serviceId.split(ModelDelimeter.COMPONENT_SEPERATOR);
+    const serviceName = serviceIdSplit[0];
+    const serviceVersion = serviceIdSplit[1];
+    context.serviceId = serviceId;
+    if (typeof serviceInstanceId != "undefined") {
+      const serviceInstanceIdSplit = serviceInstanceId.split(ModelDelimeter.COMPONENT_SEPERATOR);
+      const sid = serviceInstanceIdSplit[0];
+      const hostName = serviceInstanceIdSplit[1];
+      context.serviceInstanceId = serviceInstanceId;
+      context.sid = sid;
+      context.hostName = hostName;
+      if (typeof serviceInstanceProcessId != "undefined") {
+        const serviceInstanceProcessIdSplit = serviceInstanceProcessId.split(ModelDelimeter.COMPONENT_SEPERATOR);
+        const pid = parseInt(serviceInstanceProcessIdSplit[0]);
+        const ppid = parseInt(serviceInstanceProcessIdSplit[1]);
+        const isMaster = pid === ppid ? true : false;
+        context.serviceInstanceProcessId = serviceInstanceProcessId;
+        context.pid = pid;
+        context.ppid = ppid;
+        context.isMaster = isMaster;
+        context.isWorker = !isMaster;
+        context.serviceName = serviceName;
+        context.serviceVersion = serviceVersion;
+        context.serviceInstanceId = serviceInstanceId;
+      }
+    }
+    return context;
+  }
+}
+function UpdateSTSTransportWithDebugger(logger, newDebugger) {
+  const stsTransport = logger.transports.find((transport) => {
+    return transport instanceof STSTransportWinston;
+  });
+  if (stsTransport) {
+    stsTransport.debugger = newDebugger;
+  }
+}
+class STSTransportWinston extends Transport {
+  constructor(opts) {
+    super(opts);
+    __privateAdd(this, _options3);
+    __privateSet(this, _options3, opts);
+  }
+  get debugger() {
+    return __privateGet(this, _options3).debugger;
+  }
+  set debugger(newDebugger) {
+    __privateGet(this, _options3).debugger = newDebugger;
+  }
+  log(info, callback) {
+    if (info[Symbol.for("level")] == "debug") {
+      if (__privateGet(this, _options3).debugger) {
+        __privateGet(this, _options3).debugger(info.message);
+      }
+    }
+    this.emit("logged", info);
+    callback();
+  }
+}
+_options3 = new WeakMap();
+export {
+  CreateServiceProcessContext,
+  IPCMessageCommand,
+  MasterProcessBase,
+  ProcessBase,
+  PublishTransportUtils,
+  STSControllerBase,
+  STSLatencyController,
+  STSLatencyRoute,
+  STSRouterBase,
+  STSTransportLoggerWinston,
+  STSTransportWinston,
+  ServerProcessBase,
+  SingleProcessBase,
+  UpdateSTSTransportWithDebugger,
+  WorkerProcessBase,
+  iss
+};
+//# sourceMappingURL=stsappframework.mjs.map