@nsshunt/stsappframework 3.1.236 → 3.1.237

package/dist/stsappframework.umd.js

@@ -0,0 +1,1954 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@nsshunt/stsutils"), require("node:fs"), require("/home/runner/work/stsappframework/stsappframework/node_modules/systeminformation/lib/index.js"), require("axios"), require("node:cluster"), require("/home/runner/work/stsappframework/stsappframework/node_modules/chalk/source/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/express/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/cluster-adapter/dist/index.js"), require("node:https"), require("node:http"), require("/home/runner/work/stsappframework/stsappframework/node_modules/prom-client/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsconfig/dist/stsconfig.mjs"), require("/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsobservability/dist/stsobservability.mjs"), require("/home/runner/work/stsappframework/stsappframework/node_modules/pidusage/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/process/browser.js"), require("os"), require("/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsdatamanagement/dist/dbaccess.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/http-status-codes/build/es/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/tiny-emitter/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/winston-transport/dist/index.js"), require("node:tls"), require("/home/runner/work/stsappframework/stsappframework/node_modules/socket.io/wrapper.mjs"), require("/home/runner/work/stsappframework/stsappframework/node_modules/cors/lib/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/cookie-parser/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/uuid/dist/esm-browser/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/on-headers/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/redis-streams-adapter/dist/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/redis/dist/index.js"), require("/home/runner/work/stsappframework/stsappframework/node_modules/jayson/index.js")) : typeof define === "function" && define.amd ? define(["exports", "@nsshunt/stsutils", "node:fs", "/home/runner/work/stsappframework/stsappframework/node_modules/systeminformation/lib/index.js", "axios", "node:cluster", "/home/runner/work/stsappframework/stsappframework/node_modules/chalk/source/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/express/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/cluster-adapter/dist/index.js", "node:https", "node:http", "/home/runner/work/stsappframework/stsappframework/node_modules/prom-client/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsconfig/dist/stsconfig.mjs", "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsobservability/dist/stsobservability.mjs", "/home/runner/work/stsappframework/stsappframework/node_modules/pidusage/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/process/browser.js", "os", "/home/runner/work/stsappframework/stsappframework/node_modules/@nsshunt/stsdatamanagement/dist/dbaccess.js", "/home/runner/work/stsappframework/stsappframework/node_modules/http-status-codes/build/es/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/tiny-emitter/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/winston-transport/dist/index.js", "node:tls", "/home/runner/work/stsappframework/stsappframework/node_modules/socket.io/wrapper.mjs", "/home/runner/work/stsappframework/stsappframework/node_modules/cors/lib/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/cookie-parser/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/uuid/dist/esm-browser/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/on-headers/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/@socket.io/redis-streams-adapter/dist/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/redis/dist/index.js", "/home/runner/work/stsappframework/stsappframework/node_modules/jayson/index.js"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@nsshunt/stsappframework"] = {}, global.stsutils, global.https, global.si, global.axios, global.cluster, global.chalk, global.express, global.index_js$3, global.https, global.http, global.index_js$2, global.stsconfig_mjs, global.stsobservability_mjs, global.pidusage, global.browser_js, global.os, global.dbaccess_js, global.index_js$1, global.index_js, global.Transport, global.tls, global.wrapper_mjs, global.cors, global.cookieParser, global.index_js$4, global.onHeaders, global.index_js$6, global.index_js$5, global.jayson));
+})(this, function(exports2, stsutils, fs, si, axios, cluster, chalk, express, index_js$3, node_https, node_http, index_js$2, stsconfig_mjs, stsobservability_mjs, pidusage, browser_js, os, dbaccess_js, index_js$1, index_js, Transport, tls, wrapper_mjs, cors, cookieParser, index_js$4, onHeaders, index_js$6, index_js$5, jayson) {
+  "use strict";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;
+  function CreateServiceProcessContext(serviceName, serviceVersion, serviceInstanceId, hostName, processId, parentProcessId) {
+    const checkParams = [
+      ["servicename", serviceName],
+      ["serviceversion", serviceVersion],
+      ["hostname", hostName],
+      ["serviceInstanceId", serviceInstanceId]
+    ];
+    stsutils.CheckValidChar(checkParams);
+    return {
+      nid: `${serviceName}${stsutils.ModelDelimeter.COMPONENT_SEPERATOR}${serviceVersion}${stsutils.ModelDelimeter.SEPERATOR}${serviceInstanceId}${stsutils.ModelDelimeter.COMPONENT_SEPERATOR}${hostName}${stsutils.ModelDelimeter.NID_SEPERATOR}${processId.toString()}${stsutils.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 index_js.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(stsobservability_mjs.Gauge.CPU_LOAD_GAUGE, {
+              val: useStatsCpu
+            });
+          }
+          const usage = browser_js.memoryUsage();
+          const telemetry = {
+            r: usage.rss,
+            t: usage.heapTotal,
+            u: usage.heapUsed,
+            x: usage.external,
+            a: usage.arrayBuffers
+          };
+          this.UpdateInstrument(stsobservability_mjs.Gauge.OBJECT_GAUGE, {
+            val: telemetry
+          });
+          this.CollectAdditionalTelemetry();
+          const totalTime = performance.now() - startTime;
+          const nextLoopTime = stsconfig_mjs.goptions.systemInformationInterval - totalTime;
+          __privateSet(this, _systemInformationInterval, setTimeout(ExecuteGetStats, nextLoopTime).unref());
+        };
+        __privateSet(this, _systemInformationInterval, setTimeout(ExecuteGetStats, stsconfig_mjs.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(stsobservability_mjs.Gauge.CONNECTION_POOL_TOTAL_GAUGE, {
+          val: data.totalCount
+        });
+        this.UpdateInstrument(stsobservability_mjs.Gauge.CONNECTION_POOL_IDLE_GAUGE, {
+          val: data.idleCount
+        });
+        this.UpdateInstrument(stsobservability_mjs.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 (stsconfig_mjs.goptions.useCPUs > 0) {
+          if (stsconfig_mjs.goptions.useCPUs >= 1) {
+            numCPUs = stsconfig_mjs.goptions.useCPUs;
+          } else {
+            numCPUs = Math.round(sysinfo.cpu.cores * stsconfig_mjs.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(stsobservability_mjs.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 (stsconfig_mjs.goptions.observabilityPublishMode.localeCompare("PROXY") === 0) {
+        publishTransportOptions = {
+          transportType: stsobservability_mjs.TransportType.RESTAPI,
+          url: `${stsconfig_mjs.goptions.imendpoint}:${stsconfig_mjs.goptions.import}${stsconfig_mjs.goptions.imapiroot}/publishmessage`,
+          // socketPath: '/var/run/sts/stsrest01.sock'
+          agentOptions: {
+            keepAlive: stsconfig_mjs.goptions.keepAlive,
+            maxSockets: stsconfig_mjs.goptions.maxSockets,
+            maxTotalSockets: stsconfig_mjs.goptions.maxTotalSockets,
+            maxFreeSockets: stsconfig_mjs.goptions.maxFreeSockets,
+            timeout: stsconfig_mjs.goptions.timeout,
+            rejectUnauthorized: stsconfig_mjs.goptions.isProduction
+            // Allows self signed certs in non production mode(s)
+          },
+          logger: this.options.publisherLogger
+        };
+      } else {
+        return;
+      }
+      const httpServer = stsconfig_mjs.goptions.STSServerType.localeCompare("EXPRESS") === 0 || stsconfig_mjs.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: stsobservability_mjs.GetInstruments("service"),
+        publishTransportBaseOptions: publishTransportOptions,
+        autoStart: true
+        /*
+        [
+            ...this.#GetDefaultServiceInstruments(httpServer),
+            ...this.GetAdditionalInstruments()
+        ]
+        */
+      };
+      __privateSet(this, _instrumentController, new stsobservability_mjs.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(dbaccess_js.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 dbaccess_js.DBAccessLayerManager().CreateAccessLayer({
+            accessLayerType: dbaccess_js.accessLayerType.postgresql,
+            accessLayerOptions: {
+              logger: this.options.logger,
+              usedefaultdb: false
+            }
+          }));
+          __privateGet(this, _accessLayer).on(dbaccess_js.IDBAccessLayerEvents.UpdateInstruments, __privateGet(this, _UpdatePGPoolManagerInstrument));
+          (async () => {
+            try {
+              const retVal = await this.accessLayer.GetResourceCount();
+              if (retVal.status !== index_js$1.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, stsconfig_mjs.goptions.masterProcessExitTime);
+      __privateAdd(this, _childProcessExitTime, stsconfig_mjs.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 index_js$2.AggregatorRegistry());
+        switch (stsconfig_mjs.goptions.STSServerType) {
+          case "EXPRESS_TLS":
+            {
+              const options = {
+                key: fs.readFileSync(this.options.httpsServerKeyPath),
+                cert: fs.readFileSync(this.options.httpsServerCertificatePath)
+              };
+              __privateSet(this, _httpServer, node_https.createServer(options, __privateGet(this, _metricsServer)));
+            }
+            break;
+          case "EXPRESS": {
+            __privateSet(this, _httpServer, node_http.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 stsconfig_mjs.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(stsobservability_mjs.Gauge.LATENCY_HISTOGRAM_GAUGE, {
+          val: timeInMs
+        });
+        this.UpdateInstrument(stsobservability_mjs.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(stsobservability_mjs.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`);
+            index_js$3.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 (stsconfig_mjs.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 stsutils.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 stsconfig_mjs.AgentManager({
+        agentOptions: {
+          keepAlive: false,
+          // Use basic defaults. This agent will not use keep-alive.
+          maxFreeSockets: stsconfig_mjs.goptions.maxFreeSockets,
+          maxSockets: stsconfig_mjs.goptions.maxSockets,
+          maxTotalSockets: stsconfig_mjs.goptions.maxTotalSockets,
+          timeout: stsconfig_mjs.goptions.timeout,
+          rejectUnauthorized: stsconfig_mjs.goptions.isProduction
+          // Allows self-signed certificates if non-production
+        }
+      }));
+    }
+    CollectAdditionalTelemetry() {
+      si.get(__privateGet(this, _siValueObject)).then((data) => {
+        this.UpdateInstrument(stsobservability_mjs.Gauge.CPU_SYSTEM_LOAD_GAUGE, {
+          val: data.currentLoad.currentLoad
+        });
+      });
+    }
+    GetAdditionalInstruments() {
+      return [
+        [stsobservability_mjs.Gauge.CPU_SYSTEM_LOAD_GAUGE, stsobservability_mjs.GaugeTypes.INSTRUMENT_GAUGE, {
+          interval: stsconfig_mjs.goptions.instrumentationObservationInterval,
+          sampleSize: stsconfig_mjs.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 stsutils.STSOptionsBase {
+    constructor(options) {
+      super(options);
+      __privateAdd(this, _ServerNetworkMiddleware_instances);
+      __privateAdd(this, _tinyEmitter, new index_js.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, index_js$4.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 stsobservability_mjs.RequestLoggerMiddleware({
+        ignoresocketio: stsconfig_mjs.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(stsobservability_mjs.Gauge.NETWORK_RX_GAUGE, {
+          Inc: data.requestBytesRead
+        });
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.NETWORK_TX_GAUGE, {
+          Inc: data.requestBytesWritten
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_AR_INC, () => {
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.ACTIVE_REQUEST_GAUGE, {
+          Inc: 1
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_AR_DEC, () => {
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.ACTIVE_REQUEST_GAUGE, {
+          Dec: 1
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_DH_VAL, (timeInMs) => {
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.DURATION_HISTOGRAM_GAUGE, {
+          val: timeInMs
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_D_VAL, (timeInMs) => {
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.DURATION_GAUGE, {
+          val: timeInMs
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_RC_INC, () => {
+        stsApp.UpdateInstrument(stsobservability_mjs.Gauge.REQUEST_COUNT_GAUGE, {
+          Inc: 1
+        });
+      });
+      requestLoggerMiddleware.on(stsobservability_mjs.RequestLoggerMiddlewareEventName.UpdateInstrument_V_INC, () => {
+        if (stsApp.InstrumentExists(stsobservability_mjs.Gauge.VELOCITY_GAUGE)) {
+          stsApp.UpdateInstrument(stsobservability_mjs.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: stsconfig_mjs.goptions.maxPayloadSize }));
+      app.use(express.json({ limit: stsconfig_mjs.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, stsconfig_mjs.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 index_js$2.AggregatorRegistry();
+        const prefix = "sts_";
+        index_js$2.collectDefaultMetrics({
+          labels: { NODE_APP_INSTANCE: process.pid },
+          prefix
+        });
+        const c = new index_js$2.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", index_js$2.register.contentType);
+            res.end(await index_js$2.register.metrics());
+          } catch (ex) {
+            res.status(500).end(ex);
+          }
+        });
+        expressServer.get("/metrics/counter", async (req, res) => {
+          try {
+            res.set("Content-Type", index_js$2.register.contentType);
+            res.end(await index_js$2.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 wrapper_mjs.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, index_js$5.createClient({ url: this.options.socketIoRedisAdaptorUrl }));
+          } else {
+            this.LogInfoMessage(`Redis url: [localhost]`);
+            __privateSet(this, _redisClient, index_js$5.createClient());
+          }
+          await __privateGet(this, _redisClient).connect();
+          __privateGet(this, _io).adapter(index_js$6.createAdapter(__privateGet(this, _redisClient)));
+          this.LogInfoMessage(`Redis successfully connected.`);
+        } else {
+          if (this.options.clusterMode) {
+            __privateGet(this, _io).adapter(index_js$3.createAdapter());
+            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, node_https.createServer(__privateGet(this, _GetTLSOptions).call(this), __privateGet(this, _expressServer).App));
+        } else {
+          __privateSet(this, _httpServer2, node_http.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 stsutils.Sleep(250);
+          await ((_a = __privateGet(this, _io)) == null ? void 0 : _a.of("/").adapter.close());
+          if (this.socketIoServerHelper !== null) {
+            await this.socketIoServerHelper.CloseAdaptors();
+            await stsutils.Sleep(50);
+            if (__privateGet(this, _redisClient)) {
+              __privateGet(this, _redisClient).disconnect();
+              await stsutils.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 stsutils.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 (stsconfig_mjs.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 stsutils.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 (stsconfig_mjs.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(stsobservability_mjs.Gauge.CPU_SYSTEM_LOAD_GAUGE, {
+          val: data.currentLoad.currentLoad
+        });
+      });
+    }
+    GetAdditionalInstruments() {
+      return [
+        [stsobservability_mjs.Gauge.CPU_SYSTEM_LOAD_GAUGE, stsobservability_mjs.GaugeTypes.INSTRUMENT_GAUGE, {
+          interval: stsconfig_mjs.goptions.instrumentationObservationInterval,
+          sampleSize: stsconfig_mjs.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: index_js$4.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: index_js$4.v4(),
+          command: IPCMessageCommand.DeleteWorker,
+          requestDetail: {
+            options,
+            workerId
+          }
+        });
+        return workerResponse;
+      });
+      __publicField(this, "GetMasterProcessOptions", async () => {
+        const parentResponse = await __privateGet(this, _SendMessageToParentProcess).call(this, {
+          requestResponse: true,
+          id: index_js$4.v4(),
+          command: IPCMessageCommand.GetConfig,
+          requestDetail: {}
+        });
+        return parentResponse;
+      });
+      __publicField(this, "GetNumCPUs", async () => {
+        const valueObject = {
+          cpu: "*"
+        };
+        const sysinfo = await si.get(valueObject);
+        let numCPUs = 2;
+        if (stsconfig_mjs.goptions.useCPUs > 0) {
+          if (stsconfig_mjs.goptions.useCPUs >= 1) {
+            numCPUs = stsconfig_mjs.goptions.useCPUs;
+          } else {
+            numCPUs = Math.round(sysinfo.cpu.cores * stsconfig_mjs.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(stsobservability_mjs.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(index_js$1.StatusCodes.OK).send(retVal);
+      } catch (error) {
+        this.stsApp.LogErrorMessage(error);
+        return res.status(index_js$1.StatusCodes.INTERNAL_SERVER_ERROR).send({ status: index_js$1.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, express.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 === stsutils.ModelDelimeter.ROOT) {
+        return { root: stsutils.ModelDelimeter.ROOT };
+      }
+      const context = { nid };
+      const idsplit = nid.split(stsutils.ModelDelimeter.SEPERATOR);
+      const serviceId = idsplit[0];
+      const serviceInstanceId = idsplit[1].split(stsutils.ModelDelimeter.NID_SEPERATOR)[0];
+      const serviceInstanceProcessId = idsplit[1].split(stsutils.ModelDelimeter.NID_SEPERATOR)[1];
+      const serviceIdSplit = serviceId.split(stsutils.ModelDelimeter.COMPONENT_SEPERATOR);
+      const serviceName = serviceIdSplit[0];
+      const serviceVersion = serviceIdSplit[1];
+      context.serviceId = serviceId;
+      if (typeof serviceInstanceId != "undefined") {
+        const serviceInstanceIdSplit = serviceInstanceId.split(stsutils.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(stsutils.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();
+  exports2.CreateServiceProcessContext = CreateServiceProcessContext;
+  exports2.IPCMessageCommand = IPCMessageCommand;
+  exports2.MasterProcessBase = MasterProcessBase;
+  exports2.ProcessBase = ProcessBase;
+  exports2.PublishTransportUtils = PublishTransportUtils;
+  exports2.STSControllerBase = STSControllerBase;
+  exports2.STSLatencyController = STSLatencyController;
+  exports2.STSLatencyRoute = STSLatencyRoute;
+  exports2.STSRouterBase = STSRouterBase;
+  exports2.STSTransportLoggerWinston = STSTransportLoggerWinston;
+  exports2.STSTransportWinston = STSTransportWinston;
+  exports2.ServerProcessBase = ServerProcessBase;
+  exports2.SingleProcessBase = SingleProcessBase;
+  exports2.UpdateSTSTransportWithDebugger = UpdateSTSTransportWithDebugger;
+  exports2.WorkerProcessBase = WorkerProcessBase;
+  exports2.iss = iss;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=stsappframework.umd.js.map