@nsshunt/stsobservability 1.0.111 → 1.0.113

package/dist/stsobservability.mjs

@@ -1,23 +1,3 @@
-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 _a, _label, _options, _data, _val, _interval, _timeoutComputeVelocity, _lastVelocity, _delta, _maxVelocity, _timerInterval, _copy, _velocity, _velocityVal, _valStack, _averageValStack, _maxAverageValStack, _maxAverageIterations, _valStackMaxLength, _valStackAverage, _timeStamp, _maxTimeDiff, _vaTimeDiff, _velocityTimeDiff, _autoComputeVelocity, _autoComputeVelocityTimeout, _countDiff, _timeDiff, _deltaCountDiff, _deltaTimeDif, _minTimeForReporting, _averageVelocity, _InstrumentVelocity_instances, ComputeVelocityByTimeDiff_fn, ComputeVelocity_fn, SetupAutoComputeVelocity_fn, GetVelocityStackAverage_fn, GetVal_fn, SetVal_fn, GetVelocity_fn, GetMaxVelocity_fn, GetDelta_fn, GetTimeStamp_fn, GetCountDiff_fn, GetTimeDiff_fn, GetDeltaCountDiff_fn, GetDeltaTimeDif_fn, GetAverageVelocity_fn, _histogramData, _val2, _copy2, _InstrumentHistogram_instances, GetVal_fn2, SetVal_fn2, GetHistogramData_fn, SetHistogramData_fn, _messages, _readPos, _maxSize, _copy3, _useLatestMessages, _consoleLogging, _instrumentLogging, _winstonLogging, _stsLogger, _InstrumentLog_instances, DumpToConsole_fn, GetVal_fn3, SetVal_fn3, _start, _copy4, _pauseVal, _InstrumentTimerGauge_instances, GetVal_fn4, SetVal_fn4, _val3, _maxval, _lastObservedValue, _timeSeriesList, _maxSampleSize, _timerInterval2, _observer, _min, _max, _observations, _total, _copy5, _InstrumentGauge_instances, GetVal_fn5, SetVal_fn5, GetMin_fn, GetMax_fn, GetAverage_fn, GetAndResetMaxVal_fn, NumberCompare_fn, GetPercentileData_fn, _val4, _copy6, _InstrumentObject_instances, GetVal_fn6, SetVal_fn6, _tinyEmitter, _RequestCompleted, _inPublish, _observer2, _publishState, _publisherTransport, _PublishInstruments_instances, PublishTimeoutLoop_fn, UpdateState_fn, _instruments, _publisher, _PublishInstrumentController_instances, GetInstrument_fn, ProcessTelemetryCommand_fn, CreateInstrument_fn, CreateInstruments_fn, _kafkaLog, _maxLogLength, _socketSubscribeKeepAlive, _options2, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn, LogErrorMessage_fn, InvokeRESTAPI_fn, _GetData, SetupTimeout_fn, AddKeepAlive_fn, RemoveKeepAlive_fn, _messageWithAckPayloadRecords, _socket, _maxReties, _timeoutValue, _options3, _SocketIoMessageSender_instances, LogDebugMessage_fn2, GetSubscribeKeepAliveAckEventName_fn, _socketSubscribeKeepAlive2, _socket2, _options4, _socketIoMessageSender, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3, LogErrorMessage_fn2, AddKeepAlive_fn2, RemoveKeepAlive_fn2, _observabilitySocketIOSubscriber, _subscriptions, _kafkaHelper, _serviceModel, _agentModel, _lambdaModel, _options5, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4, LogErrorMessage_fn3;
 import _cloneDeep from "lodash.clonedeep";
 import isNode from "detect-node";
 import { STSOptionsBase, STSAxiosConfig } from "@nsshunt/stsutils";
@@ -66,35 +46,32 @@ var GaugeTypes = /* @__PURE__ */ ((GaugeTypes2) => {
   return GaugeTypes2;
 })(GaugeTypes || {});
 class InstrumentBaseOptions {
-  constructor() {
-    __publicField(this, "fixedSize");
-    __publicField(this, "padLength");
-    __publicField(this, "label");
-  }
+  fixedSize;
+  padLength;
+  label;
 }
 class InstrumentBaseTelemetry {
 }
-_a = GaugeTypes.GAUGE_TYPE;
 class InstrumentBase {
+  #label = "";
+  #options = null;
+  #data = {};
   // Use for copy objects only.
   //protected _data: Record<string, any> = { };
   constructor(options = {}) {
-    __privateAdd(this, _label, "");
-    __privateAdd(this, _options, null);
-    __privateAdd(this, _data, {});
-    __publicField(this, _a, GaugeTypes.INSTRUMENT_OBJECT);
-    // Default Gauge type
-    __publicField(this, "val");
     if (typeof options === "string" || options instanceof String) {
       throw new Error("Instrument parameter must be an options object.");
     }
-    __privateSet(this, _options, options);
+    this.#options = options;
     if (options.label) {
-      __privateSet(this, _label, options.label);
+      this.#label = options.label;
     } else {
-      __privateSet(this, _label, "InstrumentGauge");
+      this.#label = "InstrumentGauge";
     }
   }
+  [GaugeTypes.GAUGE_TYPE] = GaugeTypes.INSTRUMENT_OBJECT;
+  // Default Gauge type
+  val;
   WithLabel(label) {
     this.label = label;
     return this;
@@ -103,12 +80,12 @@ class InstrumentBase {
     propertyNames.forEach((propertyName) => {
       Object.defineProperty(this, propertyName, {
         enumerable: true,
-        get: () => __privateGet(this, _data)[propertyName],
+        get: () => this.#data[propertyName],
         set: (value) => {
           if (value === void 0) {
             return;
           }
-          __privateGet(this, _data)[propertyName] = value;
+          this.#data[propertyName] = value;
         }
       });
     });
@@ -121,16 +98,16 @@ class InstrumentBase {
     }
   }
   get options() {
-    return __privateGet(this, _options);
+    return this.#options;
   }
   set options(optionsValue) {
-    __privateSet(this, _options, optionsValue);
+    this.#options = optionsValue;
   }
   get label() {
-    return __privateGet(this, _label);
+    return this.#label;
   }
   set label(labelValue) {
-    __privateSet(this, _label, labelValue);
+    this.#label = labelValue;
   }
   StopTimer() {
   }
@@ -163,137 +140,116 @@ class InstrumentBase {
   }
   */
 }
-_label = new WeakMap();
-_options = new WeakMap();
-_data = new WeakMap();
 class InstrumentVelocityOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "interval");
-    __publicField(this, "valStackMaxLength");
-    __publicField(this, "maxAverageValStack");
-    __publicField(this, "maxAverageIterations");
-    __publicField(this, "fromJSON");
-    __publicField(this, "initValue");
-    __publicField(this, "autoComputeVelocity");
-    __publicField(this, "velocityTimeDiff");
-    __publicField(this, "vaTimeDiff");
-    __publicField(this, "autoComputeVelocityTimeout");
-  }
+  interval;
+  valStackMaxLength;
+  maxAverageValStack;
+  maxAverageIterations;
+  fromJSON;
+  initValue;
+  autoComputeVelocity;
+  velocityTimeDiff;
+  vaTimeDiff;
+  autoComputeVelocityTimeout;
 }
 class InstrumentVelocityTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "val");
-    __publicField(this, "Inc");
-  }
+  val;
+  Inc;
 }
 class InstrumentVelocity extends InstrumentBase {
+  // eslint-disable-next-line @/no-unused-private-class-members
+  #val = 0;
+  #interval = null;
+  #timeoutComputeVelocity = null;
+  // eslint-disable-next-line @/no-unused-private-class-members
+  #lastVelocity = 0;
+  #delta = 0;
+  #maxVelocity = 0;
+  #timerInterval = 0;
+  #copy = false;
+  #velocity = 0;
+  #velocityVal = 0;
+  #valStack = [];
+  #averageValStack = [];
+  #maxAverageValStack = 0;
+  #maxAverageIterations = 0;
+  // eslint-disable-next-line @/no-unused-private-class-members
+  #valStackMaxLength = 0;
+  #valStackAverage = 0;
+  #timeStamp = 0;
+  #maxTimeDiff = 0;
+  #vaTimeDiff = 0;
+  #velocityTimeDiff = 0;
+  #autoComputeVelocity = false;
+  #autoComputeVelocityTimeout = 0;
+  // 50ms to auto computer after an update when not in auto compute mode.
+  #countDiff = 0;
+  #timeDiff = 0;
+  #deltaCountDiff = 0;
+  #deltaTimeDif = 0;
+  #minTimeForReporting = 0;
+  #averageVelocity = [];
   // timeWindow = Number of intervals to use as the sliding time window same size. Uses average value within the time window. Larger window produces a smooth (more laggy) curve. Shorter time
   // window may be "spikey" depending on the volatility of the data being recorded.
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentVelocity_instances);
-    // eslint-disable-next-line @/no-unused-private-class-members
-    __privateAdd(this, _val, 0);
-    __privateAdd(this, _interval, null);
-    __privateAdd(this, _timeoutComputeVelocity, null);
-    // eslint-disable-next-line @/no-unused-private-class-members
-    __privateAdd(this, _lastVelocity, 0);
-    __privateAdd(this, _delta, 0);
-    __privateAdd(this, _maxVelocity, 0);
-    __privateAdd(this, _timerInterval, 0);
-    __privateAdd(this, _copy, false);
-    __privateAdd(this, _velocity, 0);
-    __privateAdd(this, _velocityVal, 0);
-    __privateAdd(this, _valStack, []);
-    __privateAdd(this, _averageValStack, []);
-    __privateAdd(this, _maxAverageValStack, 0);
-    __privateAdd(this, _maxAverageIterations, 0);
-    // eslint-disable-next-line @/no-unused-private-class-members
-    __privateAdd(this, _valStackMaxLength, 0);
-    __privateAdd(this, _valStackAverage, 0);
-    __privateAdd(this, _timeStamp, 0);
-    __privateAdd(this, _maxTimeDiff, 0);
-    __privateAdd(this, _vaTimeDiff, 0);
-    __privateAdd(this, _velocityTimeDiff, 0);
-    __privateAdd(this, _autoComputeVelocity, false);
-    __privateAdd(this, _autoComputeVelocityTimeout, 0);
-    // 50ms to auto computer after an update when not in auto compute mode.
-    __privateAdd(this, _countDiff, 0);
-    __privateAdd(this, _timeDiff, 0);
-    __privateAdd(this, _deltaCountDiff, 0);
-    __privateAdd(this, _deltaTimeDif, 0);
-    __privateAdd(this, _minTimeForReporting, 0);
-    __privateAdd(this, _averageVelocity, []);
-    __publicField(this, "maxVelocity", 0);
-    __publicField(this, "delta", 0);
-    __publicField(this, "velocity", 0);
-    __publicField(this, "va", 0);
-    __publicField(this, "timeStamp", 0);
-    __publicField(this, "countDiff", 0);
-    __publicField(this, "timeDiff", 0);
-    __publicField(this, "deltaCountDiff", 0);
-    __publicField(this, "deltaTimeDif", 0);
-    __publicField(this, "averageVelocity", []);
-    __publicField(this, "val", 0);
     if (typeof options.label === "undefined") {
       this.label = "InstrumentVelocity";
     } else {
       this.label = options.label;
     }
     if (typeof options.interval === "undefined") {
-      __privateSet(this, _timerInterval, 1e3);
+      this.#timerInterval = 1e3;
     } else {
-      __privateSet(this, _timerInterval, options.interval);
+      this.#timerInterval = options.interval;
     }
     if (typeof options.valStackMaxLength === "undefined") {
-      __privateSet(this, _valStackMaxLength, 100);
+      this.#valStackMaxLength = 100;
     } else {
-      __privateSet(this, _valStackMaxLength, options.valStackMaxLength);
+      this.#valStackMaxLength = options.valStackMaxLength;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy, true);
+      this.#copy = true;
     }
     if (typeof options.autoComputeVelocity === "undefined") {
-      __privateSet(this, _autoComputeVelocity, false);
+      this.#autoComputeVelocity = false;
     } else {
-      __privateSet(this, _autoComputeVelocity, options.autoComputeVelocity);
+      this.#autoComputeVelocity = options.autoComputeVelocity;
     }
     if (typeof options.maxAverageValStack === "undefined") {
-      __privateSet(this, _maxAverageValStack, 5);
+      this.#maxAverageValStack = 5;
     } else {
-      __privateSet(this, _maxAverageValStack, options.maxAverageValStack);
+      this.#maxAverageValStack = options.maxAverageValStack;
     }
     if (typeof options.maxAverageIterations === "undefined") {
-      __privateSet(this, _maxAverageIterations, 3);
+      this.#maxAverageIterations = 3;
     } else {
-      __privateSet(this, _maxAverageIterations, options.maxAverageIterations);
+      this.#maxAverageIterations = options.maxAverageIterations;
     }
     if (typeof options.velocityTimeDiff === "undefined") {
-      __privateSet(this, _velocityTimeDiff, 5e3);
+      this.#velocityTimeDiff = 5e3;
     } else {
-      __privateSet(this, _velocityTimeDiff, options.velocityTimeDiff);
+      this.#velocityTimeDiff = options.velocityTimeDiff;
     }
     if (typeof options.vaTimeDiff === "undefined") {
-      __privateSet(this, _vaTimeDiff, 1e4);
+      this.#vaTimeDiff = 1e4;
     } else {
-      __privateSet(this, _vaTimeDiff, options.vaTimeDiff);
+      this.#vaTimeDiff = options.vaTimeDiff;
     }
     if (typeof options.autoComputeVelocityTimeout === "undefined") {
-      __privateSet(this, _autoComputeVelocityTimeout, 50);
+      this.#autoComputeVelocityTimeout = 50;
     } else {
-      __privateSet(this, _autoComputeVelocityTimeout, options.autoComputeVelocityTimeout);
+      this.#autoComputeVelocityTimeout = options.autoComputeVelocityTimeout;
     }
-    __privateSet(this, _maxTimeDiff, __privateGet(this, _vaTimeDiff) * 2);
-    __privateSet(this, _minTimeForReporting, __privateGet(this, _vaTimeDiff) + 2e3);
+    this.#maxTimeDiff = this.#vaTimeDiff * 2;
+    this.#minTimeForReporting = this.#vaTimeDiff + 2e3;
     Object.defineProperty(this, GaugeTypes.GAUGE_TYPE, {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_VELOCITY
     });
-    if (__privateGet(this, _copy)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val",
         "maxVelocity",
@@ -310,52 +266,52 @@ class InstrumentVelocity extends InstrumentBase {
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetVal_fn).call(this),
+        get: () => this.#GetVal(),
         set: (value) => {
-          __privateMethod(this, _InstrumentVelocity_instances, SetVal_fn).call(this, value);
+          this.#SetVal(value);
         }
       });
       Object.defineProperty(this, "maxVelocity", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetMaxVelocity_fn).call(this)
+        get: () => this.#GetMaxVelocity()
       });
       Object.defineProperty(this, "delta", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetDelta_fn).call(this)
+        get: () => this.#GetDelta()
       });
       Object.defineProperty(this, "velocity", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetVelocity_fn).call(this)
+        get: () => this.#GetVelocity()
       });
       Object.defineProperty(this, "va", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetVelocityStackAverage_fn).call(this)
+        get: () => this.#GetVelocityStackAverage()
       });
       Object.defineProperty(this, "timeStamp", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetTimeStamp_fn).call(this)
+        get: () => this.#GetTimeStamp()
       });
       Object.defineProperty(this, "countDiff", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetCountDiff_fn).call(this)
+        get: () => this.#GetCountDiff()
       });
       Object.defineProperty(this, "timeDiff", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetTimeDiff_fn).call(this)
+        get: () => this.#GetTimeDiff()
       });
       Object.defineProperty(this, "deltaCountDiff", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetDeltaCountDiff_fn).call(this)
+        get: () => this.#GetDeltaCountDiff()
       });
       Object.defineProperty(this, "deltaTimeDif", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetDeltaTimeDif_fn).call(this)
+        get: () => this.#GetDeltaTimeDif()
       });
       Object.defineProperty(this, "averageVelocity", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentVelocity_instances, GetAverageVelocity_fn).call(this)
+        get: () => this.#GetAverageVelocity()
       });
-      if (__privateGet(this, _timerInterval) > 0 && __privateGet(this, _autoComputeVelocity) === false) {
+      if (this.#timerInterval > 0 && this.#autoComputeVelocity === false) {
         this._StartTimer();
       }
     }
@@ -377,221 +333,203 @@ class InstrumentVelocity extends InstrumentBase {
       this.averageVelocity = _cloneDeep(result.averageVelocity);
     }
   }
+  maxVelocity = 0;
+  delta = 0;
+  velocity = 0;
+  va = 0;
+  timeStamp = 0;
+  countDiff = 0;
+  timeDiff = 0;
+  deltaCountDiff = 0;
+  deltaTimeDif = 0;
+  averageVelocity = [];
+  val = 0;
   WithValStackMaxLength(valStackMaxLength) {
-    __privateSet(this, _valStackMaxLength, valStackMaxLength);
-    __privateSet(this, _valStack, []);
+    this.#valStackMaxLength = valStackMaxLength;
+    this.#valStack = [];
     return this;
   }
   _StartTimer() {
-    __privateSet(this, _interval, setInterval(() => {
-      __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocity_fn).call(this);
-      let pushVal = __privateGet(this, _velocity);
-      for (let i = 0; i < __privateGet(this, _maxAverageIterations); i++) {
-        if (!__privateGet(this, _averageValStack)[i]) {
-          __privateGet(this, _averageValStack)[i] = [];
+    this.#interval = setInterval(() => {
+      this.#ComputeVelocity();
+      let pushVal = this.#velocity;
+      for (let i = 0; i < this.#maxAverageIterations; i++) {
+        if (!this.#averageValStack[i]) {
+          this.#averageValStack[i] = [];
         }
-        __privateGet(this, _averageValStack)[i].push(pushVal);
-        if (__privateGet(this, _averageValStack)[i].length > __privateGet(this, _maxAverageValStack)) {
-          __privateGet(this, _averageValStack)[i].shift();
+        this.#averageValStack[i].push(pushVal);
+        if (this.#averageValStack[i].length > this.#maxAverageValStack) {
+          this.#averageValStack[i].shift();
         }
-        pushVal = __privateGet(this, _averageValStack)[i].reduce((prev, current) => prev + current) / __privateGet(this, _averageValStack)[i].length;
-        __privateGet(this, _averageVelocity)[i] = pushVal;
+        pushVal = this.#averageValStack[i].reduce((prev, current) => prev + current) / this.#averageValStack[i].length;
+        this.#averageVelocity[i] = pushVal;
       }
-    }, __privateGet(this, _timerInterval)));
+    }, this.#timerInterval);
     if (isNode) {
-      __privateGet(this, _interval).unref();
-    }
-  }
-  Inc(incVal = 1) {
-    __privateSet(this, _velocityVal, __privateGet(this, _velocityVal) + incVal);
-    if (__privateGet(this, _autoComputeVelocity)) {
-      __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocity_fn).call(this);
-    } else {
-      __privateMethod(this, _InstrumentVelocity_instances, SetupAutoComputeVelocity_fn).call(this);
-    }
-  }
-  StopTimer() {
-    if (__privateGet(this, _interval) !== null) {
-      clearTimeout(__privateGet(this, _interval));
-      __privateSet(this, _interval, null);
-    }
-  }
-  ProcessTelemetry(telemetry) {
-    if (telemetry.Inc !== void 0) {
-      this.Inc(telemetry.Inc);
-    }
-    if (telemetry.val !== void 0) {
-      this.val = telemetry.val;
-    }
-  }
-}
-_val = new WeakMap();
-_interval = new WeakMap();
-_timeoutComputeVelocity = new WeakMap();
-_lastVelocity = new WeakMap();
-_delta = new WeakMap();
-_maxVelocity = new WeakMap();
-_timerInterval = new WeakMap();
-_copy = new WeakMap();
-_velocity = new WeakMap();
-_velocityVal = new WeakMap();
-_valStack = new WeakMap();
-_averageValStack = new WeakMap();
-_maxAverageValStack = new WeakMap();
-_maxAverageIterations = new WeakMap();
-_valStackMaxLength = new WeakMap();
-_valStackAverage = new WeakMap();
-_timeStamp = new WeakMap();
-_maxTimeDiff = new WeakMap();
-_vaTimeDiff = new WeakMap();
-_velocityTimeDiff = new WeakMap();
-_autoComputeVelocity = new WeakMap();
-_autoComputeVelocityTimeout = new WeakMap();
-_countDiff = new WeakMap();
-_timeDiff = new WeakMap();
-_deltaCountDiff = new WeakMap();
-_deltaTimeDif = new WeakMap();
-_minTimeForReporting = new WeakMap();
-_averageVelocity = new WeakMap();
-_InstrumentVelocity_instances = new WeakSet();
-ComputeVelocityByTimeDiff_fn = function(checkTimeDiff, checkDeltaTimeDiff) {
-  let val = 0;
-  let deltaVal = 0;
-  let countDiff = 0;
-  let timeDiff = 0;
-  let deltaCountDiff = 0;
-  let deltaTimeDiff = 0;
-  if (__privateGet(this, _valStack).length > 1 && __privateGet(this, _valStack)[__privateGet(this, _valStack).length - 1].timeStamp - __privateGet(this, _valStack)[0].timeStamp > __privateGet(this, _minTimeForReporting)) {
-    const dp = __privateGet(this, _valStack)[__privateGet(this, _valStack).length - 1];
-    let timeDiffPos = -1;
-    let deltaDiffPos = -1;
-    for (let i = __privateGet(this, _valStack).length - 2; i > -1; i--) {
-      if (timeDiffPos === -1 && __privateGet(this, _timeStamp) - __privateGet(this, _valStack)[i].timeStamp >= checkTimeDiff) {
-        timeDiffPos = i;
-        if (checkDeltaTimeDiff === 0) {
+      this.#interval.unref();
+    }
+  }
+  #ComputeVelocityByTimeDiff(checkTimeDiff, checkDeltaTimeDiff) {
+    let val = 0;
+    let deltaVal = 0;
+    let countDiff = 0;
+    let timeDiff = 0;
+    let deltaCountDiff = 0;
+    let deltaTimeDiff = 0;
+    if (this.#valStack.length > 1 && this.#valStack[this.#valStack.length - 1].timeStamp - this.#valStack[0].timeStamp > this.#minTimeForReporting) {
+      const dp = this.#valStack[this.#valStack.length - 1];
+      let timeDiffPos = -1;
+      let deltaDiffPos = -1;
+      for (let i = this.#valStack.length - 2; i > -1; i--) {
+        if (timeDiffPos === -1 && this.#timeStamp - this.#valStack[i].timeStamp >= checkTimeDiff) {
+          timeDiffPos = i;
+          if (checkDeltaTimeDiff === 0) {
+            break;
+          }
+        }
+        if (deltaDiffPos === -1 && this.#timeStamp - this.#valStack[i].timeStamp >= checkDeltaTimeDiff) {
+          deltaDiffPos = i;
+        }
+        if (timeDiffPos !== -1 && deltaDiffPos !== -1) {
           break;
         }
       }
-      if (deltaDiffPos === -1 && __privateGet(this, _timeStamp) - __privateGet(this, _valStack)[i].timeStamp >= checkDeltaTimeDiff) {
-        deltaDiffPos = i;
-      }
-      if (timeDiffPos !== -1 && deltaDiffPos !== -1) {
-        break;
-      }
-    }
-    if (timeDiffPos > -1) {
-      countDiff = dp.count - __privateGet(this, _valStack)[timeDiffPos].count;
-      if (countDiff > 0) {
-        timeDiff = dp.timeStamp - __privateGet(this, _valStack)[timeDiffPos].timeStamp;
-        if (timeDiff > 0) {
-          val = 1e3 / timeDiff * countDiff;
+      if (timeDiffPos > -1) {
+        countDiff = dp.count - this.#valStack[timeDiffPos].count;
+        if (countDiff > 0) {
+          timeDiff = dp.timeStamp - this.#valStack[timeDiffPos].timeStamp;
+          if (timeDiff > 0) {
+            val = 1e3 / timeDiff * countDiff;
+          } else {
+            val = 0;
+          }
         } else {
           val = 0;
         }
       } else {
         val = 0;
       }
-    } else {
-      val = 0;
-    }
-    if (deltaDiffPos > -1) {
-      deltaCountDiff = __privateGet(this, _valStack)[timeDiffPos].count - __privateGet(this, _valStack)[deltaDiffPos].count;
-      if (deltaCountDiff > 0) {
-        deltaTimeDiff = __privateGet(this, _valStack)[timeDiffPos].timeStamp - __privateGet(this, _valStack)[deltaDiffPos].timeStamp;
-        if (deltaTimeDiff > 0) {
-          deltaVal = 1e3 / deltaTimeDiff * deltaTimeDiff;
+      if (deltaDiffPos > -1) {
+        deltaCountDiff = this.#valStack[timeDiffPos].count - this.#valStack[deltaDiffPos].count;
+        if (deltaCountDiff > 0) {
+          deltaTimeDiff = this.#valStack[timeDiffPos].timeStamp - this.#valStack[deltaDiffPos].timeStamp;
+          if (deltaTimeDiff > 0) {
+            deltaVal = 1e3 / deltaTimeDiff * deltaTimeDiff;
+          } else {
+            deltaVal = 0;
+          }
         } else {
           deltaVal = 0;
         }
       } else {
         deltaVal = 0;
       }
+    }
+    return {
+      val,
+      countDiff,
+      timeDiff,
+      deltaVal,
+      deltaCountDiff,
+      deltaTimeDiff
+    };
+  }
+  #ComputeVelocity() {
+    const dp = {
+      timeStamp: performance.now(),
+      count: this.#velocityVal
+    };
+    this.#valStack.push(dp);
+    this.#timeStamp = dp.timeStamp;
+    while (this.#valStack.length > 0 && this.#timeStamp - this.#valStack[0].timeStamp > this.#maxTimeDiff) {
+      this.#valStack.shift();
+    }
+    const valStackAverageDataPoint = this.#ComputeVelocityByTimeDiff(this.#vaTimeDiff, 0);
+    this.#valStackAverage = valStackAverageDataPoint.val;
+    const velocityDataPoint = this.#ComputeVelocityByTimeDiff(this.#velocityTimeDiff, this.#velocityTimeDiff * 2);
+    this.#velocity = velocityDataPoint.val;
+    this.#delta = velocityDataPoint.val - velocityDataPoint.deltaVal;
+    this.#countDiff = velocityDataPoint.countDiff;
+    this.#timeDiff = velocityDataPoint.timeDiff;
+    this.#deltaCountDiff = velocityDataPoint.deltaCountDiff;
+    this.#deltaTimeDif = velocityDataPoint.deltaTimeDiff;
+    this.#lastVelocity = this.#velocity;
+    if (this.#velocity > this.#maxVelocity) {
+      this.#maxVelocity = this.#velocity;
+    }
+  }
+  #SetupAutoComputeVelocity() {
+    if (this.#timeoutComputeVelocity) {
+      clearTimeout(this.#timeoutComputeVelocity);
+    }
+    this.#timeoutComputeVelocity = setTimeout(() => {
+      this.#ComputeVelocity();
+    }, this.#autoComputeVelocityTimeout);
+  }
+  #GetVelocityStackAverage() {
+    return this.GetNumber(this.#valStackAverage);
+  }
+  Inc(incVal = 1) {
+    this.#velocityVal += incVal;
+    if (this.#autoComputeVelocity) {
+      this.#ComputeVelocity();
     } else {
-      deltaVal = 0;
+      this.#SetupAutoComputeVelocity();
     }
   }
-  return {
-    val,
-    countDiff,
-    timeDiff,
-    deltaVal,
-    deltaCountDiff,
-    deltaTimeDiff
-  };
-};
-ComputeVelocity_fn = function() {
-  const dp = {
-    timeStamp: performance.now(),
-    count: __privateGet(this, _velocityVal)
-  };
-  __privateGet(this, _valStack).push(dp);
-  __privateSet(this, _timeStamp, dp.timeStamp);
-  while (__privateGet(this, _valStack).length > 0 && __privateGet(this, _timeStamp) - __privateGet(this, _valStack)[0].timeStamp > __privateGet(this, _maxTimeDiff)) {
-    __privateGet(this, _valStack).shift();
-  }
-  const valStackAverageDataPoint = __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocityByTimeDiff_fn).call(this, __privateGet(this, _vaTimeDiff), 0);
-  __privateSet(this, _valStackAverage, valStackAverageDataPoint.val);
-  const velocityDataPoint = __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocityByTimeDiff_fn).call(this, __privateGet(this, _velocityTimeDiff), __privateGet(this, _velocityTimeDiff) * 2);
-  __privateSet(this, _velocity, velocityDataPoint.val);
-  __privateSet(this, _delta, velocityDataPoint.val - velocityDataPoint.deltaVal);
-  __privateSet(this, _countDiff, velocityDataPoint.countDiff);
-  __privateSet(this, _timeDiff, velocityDataPoint.timeDiff);
-  __privateSet(this, _deltaCountDiff, velocityDataPoint.deltaCountDiff);
-  __privateSet(this, _deltaTimeDif, velocityDataPoint.deltaTimeDiff);
-  __privateSet(this, _lastVelocity, __privateGet(this, _velocity));
-  if (__privateGet(this, _velocity) > __privateGet(this, _maxVelocity)) {
-    __privateSet(this, _maxVelocity, __privateGet(this, _velocity));
+  #GetVal() {
+    return this.GetNumber(this.#velocityVal);
   }
-};
-SetupAutoComputeVelocity_fn = function() {
-  if (__privateGet(this, _timeoutComputeVelocity)) {
-    clearTimeout(__privateGet(this, _timeoutComputeVelocity));
+  #SetVal(updatedValue) {
+    this.#velocityVal = updatedValue;
+    if (this.#autoComputeVelocity) {
+      this.#ComputeVelocity();
+    } else {
+      this.#SetupAutoComputeVelocity();
+    }
   }
-  __privateSet(this, _timeoutComputeVelocity, setTimeout(() => {
-    __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocity_fn).call(this);
-  }, __privateGet(this, _autoComputeVelocityTimeout)));
-};
-GetVelocityStackAverage_fn = function() {
-  return this.GetNumber(__privateGet(this, _valStackAverage));
-};
-GetVal_fn = function() {
-  return this.GetNumber(__privateGet(this, _velocityVal));
-};
-SetVal_fn = function(updatedValue) {
-  __privateSet(this, _velocityVal, updatedValue);
-  if (__privateGet(this, _autoComputeVelocity)) {
-    __privateMethod(this, _InstrumentVelocity_instances, ComputeVelocity_fn).call(this);
-  } else {
-    __privateMethod(this, _InstrumentVelocity_instances, SetupAutoComputeVelocity_fn).call(this);
+  #GetVelocity() {
+    return this.GetNumber(this.#velocity);
   }
-};
-GetVelocity_fn = function() {
-  return this.GetNumber(__privateGet(this, _velocity));
-};
-GetMaxVelocity_fn = function() {
-  return this.GetNumber(__privateGet(this, _maxVelocity));
-};
-GetDelta_fn = function() {
-  return this.GetNumber(__privateGet(this, _delta));
-};
-GetTimeStamp_fn = function() {
-  return this.GetNumber(__privateGet(this, _timeStamp));
-};
-GetCountDiff_fn = function() {
-  return this.GetNumber(__privateGet(this, _countDiff));
-};
-GetTimeDiff_fn = function() {
-  return this.GetNumber(__privateGet(this, _timeDiff));
-};
-GetDeltaCountDiff_fn = function() {
-  return this.GetNumber(__privateGet(this, _deltaCountDiff));
-};
-GetDeltaTimeDif_fn = function() {
-  return this.GetNumber(__privateGet(this, _deltaTimeDif));
-};
-GetAverageVelocity_fn = function() {
-  return __privateGet(this, _averageVelocity);
-};
+  #GetMaxVelocity() {
+    return this.GetNumber(this.#maxVelocity);
+  }
+  #GetDelta() {
+    return this.GetNumber(this.#delta);
+  }
+  #GetTimeStamp() {
+    return this.GetNumber(this.#timeStamp);
+  }
+  #GetCountDiff() {
+    return this.GetNumber(this.#countDiff);
+  }
+  #GetTimeDiff() {
+    return this.GetNumber(this.#timeDiff);
+  }
+  #GetDeltaCountDiff() {
+    return this.GetNumber(this.#deltaCountDiff);
+  }
+  #GetDeltaTimeDif() {
+    return this.GetNumber(this.#deltaTimeDif);
+  }
+  #GetAverageVelocity() {
+    return this.#averageVelocity;
+  }
+  StopTimer() {
+    if (this.#interval !== null) {
+      clearTimeout(this.#interval);
+      this.#interval = null;
+    }
+  }
+  ProcessTelemetry(telemetry) {
+    if (telemetry.Inc !== void 0) {
+      this.Inc(telemetry.Inc);
+    }
+    if (telemetry.val !== void 0) {
+      this.val = telemetry.val;
+    }
+  }
+}
 var HistogramDataElementPos = /* @__PURE__ */ ((HistogramDataElementPos2) => {
   HistogramDataElementPos2[HistogramDataElementPos2["val"] = 0] = "val";
   HistogramDataElementPos2[HistogramDataElementPos2["label"] = 1] = "label";
@@ -599,28 +537,19 @@ var HistogramDataElementPos = /* @__PURE__ */ ((HistogramDataElementPos2) => {
   return HistogramDataElementPos2;
 })(HistogramDataElementPos || {});
 class InstrumentHistogramOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "histogramData");
-    __publicField(this, "initValue");
-    __publicField(this, "fromJSON");
-  }
+  histogramData;
+  initValue;
+  fromJSON;
 }
 class InstrumentHistogramTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "val");
-  }
+  val;
 }
 class InstrumentHistogram extends InstrumentBase {
+  #histogramData = [];
+  #val = 0;
+  #copy = false;
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentHistogram_instances);
-    __privateAdd(this, _histogramData, []);
-    __privateAdd(this, _val2, 0);
-    __privateAdd(this, _copy2, false);
-    __publicField(this, "hist", []);
-    __publicField(this, "val", 0);
     if (typeof options.label === "undefined") {
       this.label = "InstrumentHistogram";
     } else {
@@ -633,12 +562,12 @@ class InstrumentHistogram extends InstrumentBase {
       histogramData = options.histogramData;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy2, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy2, true);
+      this.#copy = true;
     }
     if (histogramData === null) {
-      __privateSet(this, _histogramData, [
+      this.#histogramData = [
         [0, "10", 10],
         [0, "20", 20],
         [0, "50", 50],
@@ -646,13 +575,13 @@ class InstrumentHistogram extends InstrumentBase {
         [0, "1000", 1e3],
         [0, "5000", 5e3],
         [0, "EE", 0]
-      ]);
+      ];
     } else if (Array.isArray(histogramData)) {
-      __privateSet(this, _histogramData, []);
+      this.#histogramData = [];
       for (let i = 0; i < histogramData.length; i++) {
-        __privateGet(this, _histogramData).push([0, "" + histogramData[i], parseFloat(histogramData[i].toString())]);
+        this.#histogramData.push([0, "" + histogramData[i], parseFloat(histogramData[i].toString())]);
       }
-      __privateGet(this, _histogramData).push([0, "EE", 0]);
+      this.#histogramData.push([0, "EE", 0]);
     } else {
       throw new Error(`Passed [${histogramData}] must be an array.`);
     }
@@ -660,7 +589,7 @@ class InstrumentHistogram extends InstrumentBase {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_HISTOGRAM
     });
-    if (__privateGet(this, _copy2)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val",
         "hist"
@@ -668,30 +597,32 @@ class InstrumentHistogram extends InstrumentBase {
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentHistogram_instances, GetVal_fn2).call(this),
+        get: () => this.#GetVal(),
         set: (value) => {
-          __privateMethod(this, _InstrumentHistogram_instances, SetVal_fn2).call(this, value);
+          this.#SetVal(value);
         }
       });
       Object.defineProperty(this, "hist", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentHistogram_instances, GetHistogramData_fn).call(this),
+        get: () => this.#GetHistogramData(),
         set: (value) => {
-          __privateMethod(this, _InstrumentHistogram_instances, SetHistogramData_fn).call(this, value);
+          this.#SetHistogramData(value);
         }
       });
     }
     if (typeof options.initValue !== "undefined") {
-      __privateSet(this, _val2, options.initValue);
+      this.#val = options.initValue;
     }
     if (typeof options.fromJSON !== "undefined") {
       const result = _cloneDeep(options.fromJSON);
-      __privateSet(this, _val2, result.val);
+      this.#val = result.val;
       this.hist = result.hist;
     }
   }
+  hist = [];
+  val = 0;
   WithInitVal(initVal) {
-    __privateSet(this, _val2, initVal);
+    this.#val = initVal;
     return this;
   }
   ResetHistogramData() {
@@ -700,27 +631,34 @@ class InstrumentHistogram extends InstrumentBase {
     }
   }
   AddObservation(updateValue) {
-    if (__privateGet(this, _copy2)) {
+    if (this.#copy) {
       throw new Error("Cannot add observations from the copy version of this class.");
     }
     let i = 0;
-    for (; i < __privateGet(this, _histogramData).length - 1; i++) {
-      if (updateValue <= __privateGet(this, _histogramData)[i][
+    for (; i < this.#histogramData.length - 1; i++) {
+      if (updateValue <= this.#histogramData[i][
         2
         /* breakPoint */
       ]) {
-        __privateGet(this, _histogramData)[i][
+        this.#histogramData[i][
           0
           /* val */
         ]++;
         return;
       }
     }
-    __privateGet(this, _histogramData)[i][
+    this.#histogramData[i][
       0
       /* val */
     ]++;
   }
+  #GetVal() {
+    return this.GetNumber(this.#val);
+  }
+  #SetVal(value) {
+    this.#val = value;
+    this.AddObservation(value);
+  }
   get formattedHistogramData() {
     let retVal = "";
     let sep = "";
@@ -736,6 +674,12 @@ class InstrumentHistogram extends InstrumentBase {
     }
     return retVal;
   }
+  #GetHistogramData() {
+    return this.#histogramData;
+  }
+  #SetHistogramData(value) {
+    this.#histogramData = value;
+  }
   static AddHistogramDataEx(histoA, histoB) {
     if (histoA === null) {
       return _cloneDeep(histoB);
@@ -820,109 +764,84 @@ class InstrumentHistogram extends InstrumentBase {
     }
   }
 }
-_histogramData = new WeakMap();
-_val2 = new WeakMap();
-_copy2 = new WeakMap();
-_InstrumentHistogram_instances = new WeakSet();
-GetVal_fn2 = function() {
-  return this.GetNumber(__privateGet(this, _val2));
-};
-SetVal_fn2 = function(value) {
-  __privateSet(this, _val2, value);
-  this.AddObservation(value);
-};
-GetHistogramData_fn = function() {
-  return __privateGet(this, _histogramData);
-};
-SetHistogramData_fn = function(value) {
-  __privateSet(this, _histogramData, value);
-};
 class InstrumentLogOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "maxSize");
-    __publicField(this, "useLatestMessages");
-    __publicField(this, "consoleLogging");
-    __publicField(this, "instrumentLogging");
-    __publicField(this, "winstonLogging");
-    __publicField(this, "fromJSON");
-    __publicField(this, "initValue");
-    __publicField(this, "logger");
-  }
+  maxSize;
+  useLatestMessages;
+  consoleLogging;
+  instrumentLogging;
+  winstonLogging;
+  fromJSON;
+  initValue;
+  logger;
 }
 class InstrumentLogTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "Append");
-    __publicField(this, "LogMessage");
-    __publicField(this, "val");
-    __publicField(this, "ResetLog");
-  }
+  Append;
+  LogMessage;
+  val;
+  ResetLog;
 }
 class InstrumentLog extends InstrumentBase {
+  #messages = [];
+  #readPos = 0;
+  #maxSize = 200;
+  // Max length of cached log messages
+  #copy = false;
+  #useLatestMessages = false;
+  #consoleLogging = false;
+  #instrumentLogging = true;
+  #winstonLogging = false;
+  #stsLogger;
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentLog_instances);
-    __privateAdd(this, _messages, []);
-    __privateAdd(this, _readPos, 0);
-    __privateAdd(this, _maxSize, 200);
-    // Max length of cached log messages
-    __privateAdd(this, _copy3, false);
-    __privateAdd(this, _useLatestMessages, false);
-    __privateAdd(this, _consoleLogging, false);
-    __privateAdd(this, _instrumentLogging, true);
-    __privateAdd(this, _winstonLogging, false);
-    __privateAdd(this, _stsLogger);
-    __publicField(this, "val", []);
     if (typeof options.label === "undefined") {
       this.label = "InstrumentLog";
     } else {
       this.label = options.label;
     }
     if (typeof options.maxSize === "undefined") {
-      __privateSet(this, _maxSize, 200);
+      this.#maxSize = 200;
     } else {
-      __privateSet(this, _maxSize, options.maxSize);
+      this.#maxSize = options.maxSize;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy3, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy3, true);
+      this.#copy = true;
     }
     if (typeof options.useLatestMessages === "undefined") {
-      __privateSet(this, _useLatestMessages, false);
+      this.#useLatestMessages = false;
     } else {
-      __privateSet(this, _useLatestMessages, options.useLatestMessages);
+      this.#useLatestMessages = options.useLatestMessages;
     }
     if (typeof options.consoleLogging === "undefined") {
-      __privateSet(this, _consoleLogging, false);
+      this.#consoleLogging = false;
     } else {
-      __privateSet(this, _consoleLogging, options.consoleLogging);
+      this.#consoleLogging = options.consoleLogging;
     }
     if (typeof options.instrumentLogging === "undefined") {
-      __privateSet(this, _instrumentLogging, true);
+      this.#instrumentLogging = true;
     } else {
-      __privateSet(this, _instrumentLogging, options.instrumentLogging);
+      this.#instrumentLogging = options.instrumentLogging;
     }
     if (typeof options.winstonLogging === "undefined") {
-      __privateSet(this, _winstonLogging, false);
+      this.#winstonLogging = false;
     } else {
-      __privateSet(this, _winstonLogging, options.winstonLogging);
+      this.#winstonLogging = options.winstonLogging;
     }
     Object.defineProperty(this, GaugeTypes.GAUGE_TYPE, {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_LOG
     });
-    if (__privateGet(this, _copy3)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val"
       ]);
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => _cloneDeep(__privateMethod(this, _InstrumentLog_instances, GetVal_fn3).call(this)),
+        get: () => _cloneDeep(this.#GetVal()),
         set: (value) => {
-          __privateMethod(this, _InstrumentLog_instances, SetVal_fn3).call(this, value);
+          this.#SetVal(value);
         }
       });
     }
@@ -934,42 +853,49 @@ class InstrumentLog extends InstrumentBase {
       this.val = result.val;
     }
   }
+  val = [];
   WithMaxSize(maxSize) {
-    __privateSet(this, _maxSize, maxSize);
+    this.#maxSize = maxSize;
     return this;
   }
   WithUseLatestMessages(useLatestMessages) {
-    __privateSet(this, _useLatestMessages, useLatestMessages);
+    this.#useLatestMessages = useLatestMessages;
     return this;
   }
   WithConsoleLogging(consoleLogging2) {
-    __privateSet(this, _consoleLogging, consoleLogging2);
+    this.#consoleLogging = consoleLogging2;
     return this;
   }
   WithInstrumentLogging(instrumentLogging2) {
-    __privateSet(this, _instrumentLogging, instrumentLogging2);
+    this.#instrumentLogging = instrumentLogging2;
     return this;
   }
   get MaxSize() {
-    return __privateGet(this, _maxSize);
+    return this.#maxSize;
   }
   set MaxSize(maxSize) {
-    __privateSet(this, _maxSize, maxSize);
+    this.#maxSize = maxSize;
+  }
+  #DumpToConsole() {
+    const logReport = this.GetMessagesSinceLastRead();
+    for (let i = 0; i < logReport.length; i++) {
+      console.log(logReport[i]);
+    }
   }
   get consoleLogging() {
-    return __privateGet(this, _consoleLogging);
+    return this.#consoleLogging;
   }
   set consoleLogging(value) {
-    __privateSet(this, _consoleLogging, value);
+    this.#consoleLogging = value;
     if (value === true) {
-      __privateMethod(this, _InstrumentLog_instances, DumpToConsole_fn).call(this);
+      this.#DumpToConsole();
     }
   }
   get instrumentLogging() {
-    return __privateGet(this, _instrumentLogging);
+    return this.#instrumentLogging;
   }
   set instrumentLogging(value) {
-    __privateSet(this, _instrumentLogging, value);
+    this.#instrumentLogging = value;
   }
   Append(messageArray) {
     for (let i = 0; i < messageArray.length; i++) {
@@ -977,54 +903,65 @@ class InstrumentLog extends InstrumentBase {
     }
   }
   error(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).error(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.error(message);
   }
   warn(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).warn(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.warn(message);
   }
   info(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).info(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.info(message);
   }
   http(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).http(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.http(message);
   }
   verbose(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).verbose(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.verbose(message);
   }
   debug(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).debug(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.debug(message);
   }
   silly(message) {
-    if (__privateGet(this, _winstonLogging) && __privateGet(this, _stsLogger)) __privateGet(this, _stsLogger).silly(message);
+    if (this.#winstonLogging && this.#stsLogger) this.#stsLogger.silly(message);
   }
   LogMessage(message) {
-    if (__privateGet(this, _copy3)) {
+    if (this.#copy) {
       throw new Error("Cannot add log messages from the copy version of this class.");
     }
-    if (__privateGet(this, _consoleLogging) === true) {
+    if (this.#consoleLogging === true) {
       console.log(message);
     }
-    if (__privateGet(this, _instrumentLogging) === false) {
+    if (this.#instrumentLogging === false) {
       return;
     }
-    __privateGet(this, _messages).push(message);
-    if (__privateGet(this, _messages).length > __privateGet(this, _maxSize)) {
-      __privateGet(this, _messages).shift();
-      __privateSet(this, _readPos, __privateGet(this, _readPos) > 0 ? __privateGet(this, _readPos) - 1 : 0);
+    this.#messages.push(message);
+    if (this.#messages.length > this.#maxSize) {
+      this.#messages.shift();
+      this.#readPos = this.#readPos > 0 ? this.#readPos - 1 : 0;
     }
   }
+  #GetVal() {
+    if (this.#useLatestMessages) {
+      return this.GetMessagesSinceLastRead();
+    } else {
+      return this.#messages;
+    }
+  }
+  #SetVal(updatedValue) {
+    this.#messages = updatedValue;
+    this.#readPos = 0;
+  }
   GetMessagesNoUpdate() {
-    return __privateGet(this, _messages).slice(__privateGet(this, _readPos));
+    return this.#messages.slice(this.#readPos);
   }
   // This will return only those messages that have been added since the last read
   GetMessagesSinceLastRead() {
-    const retVal = __privateGet(this, _messages).slice(__privateGet(this, _readPos));
-    __privateSet(this, _readPos, __privateGet(this, _messages).length);
+    const retVal = this.#messages.slice(this.#readPos);
+    this.#readPos = this.#messages.length;
     return retVal;
   }
   ResetLog() {
-    __privateSet(this, _messages, []);
-    __privateSet(this, _readPos, 0);
+    this.#messages = [];
+    this.#readPos = 0;
   }
   ProcessTelemetry(telemetry) {
     if (telemetry.val !== void 0) {
@@ -1041,81 +978,46 @@ class InstrumentLog extends InstrumentBase {
     }
   }
 }
-_messages = new WeakMap();
-_readPos = new WeakMap();
-_maxSize = new WeakMap();
-_copy3 = new WeakMap();
-_useLatestMessages = new WeakMap();
-_consoleLogging = new WeakMap();
-_instrumentLogging = new WeakMap();
-_winstonLogging = new WeakMap();
-_stsLogger = new WeakMap();
-_InstrumentLog_instances = new WeakSet();
-DumpToConsole_fn = function() {
-  const logReport = this.GetMessagesSinceLastRead();
-  for (let i = 0; i < logReport.length; i++) {
-    console.log(logReport[i]);
-  }
-};
-GetVal_fn3 = function() {
-  if (__privateGet(this, _useLatestMessages)) {
-    return this.GetMessagesSinceLastRead();
-  } else {
-    return __privateGet(this, _messages);
-  }
-};
-SetVal_fn3 = function(updatedValue) {
-  __privateSet(this, _messages, updatedValue);
-  __privateSet(this, _readPos, 0);
-};
 class InstrumentTimerOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "fromJSON");
-    __publicField(this, "initValue");
-  }
+  fromJSON;
+  initValue;
 }
 class InstrumentTimerTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "val");
-    __publicField(this, "Pause");
-    __publicField(this, "Resume");
-    __publicField(this, "Reset");
-  }
+  val;
+  Pause;
+  Resume;
+  Reset;
 }
 class InstrumentTimerGauge extends InstrumentBase {
+  #start = 0;
+  #copy = false;
+  #pauseVal = 0;
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentTimerGauge_instances);
-    __privateAdd(this, _start, 0);
-    __privateAdd(this, _copy4, false);
-    __privateAdd(this, _pauseVal, 0);
-    __publicField(this, "val", 0);
     if (typeof options.label === "undefined") {
       this.label = "InstrumentTimerGauge";
     } else {
       this.label = options.label;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy4, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy4, true);
+      this.#copy = true;
     }
     Object.defineProperty(this, GaugeTypes.GAUGE_TYPE, {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_TIMER
     });
-    if (__privateGet(this, _copy4)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val"
       ]);
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentTimerGauge_instances, GetVal_fn4).call(this),
+        get: () => this.#GetVal(),
         set: (value) => {
-          __privateMethod(this, _InstrumentTimerGauge_instances, SetVal_fn4).call(this, value);
+          this.#SetVal(value);
         }
       });
     }
@@ -1128,22 +1030,40 @@ class InstrumentTimerGauge extends InstrumentBase {
     }
     this.Reset();
   }
+  val = 0;
   // Take a snap shot of the current elapsed time. The 'clock' will still keep running.
   Pause() {
-    __privateSet(this, _pauseVal, this.val);
+    this.#pauseVal = this.val;
   }
   Resume() {
-    __privateSet(this, _pauseVal, 0);
+    this.#pauseVal = 0;
   }
   Reset() {
     if (isNode) {
-      __privateSet(this, _start, performance.now());
+      this.#start = performance.now();
+    } else {
+      this.#start = performance.now();
+    }
+  }
+  #GetVal() {
+    if (this.#pauseVal !== 0) {
+      return this.GetNumber(this.#pauseVal);
+    }
+    if (isNode) {
+      return this.GetNumber(performance.now() - this.#start);
     } else {
-      __privateSet(this, _start, performance.now());
+      return this.GetNumber(performance.now() - this.#start);
+    }
+  }
+  #SetVal(updatedValue) {
+    if (isNode) {
+      this.#start = performance.now() - updatedValue;
+    } else {
+      this.#start = performance.now() - updatedValue;
     }
   }
   get start() {
-    return __privateGet(this, _start);
+    return this.#start;
   }
   /*
      #convertMS(ms: number): string {
@@ -1176,27 +1096,6 @@ class InstrumentTimerGauge extends InstrumentBase {
     }
   }
 }
-_start = new WeakMap();
-_copy4 = new WeakMap();
-_pauseVal = new WeakMap();
-_InstrumentTimerGauge_instances = new WeakSet();
-GetVal_fn4 = function() {
-  if (__privateGet(this, _pauseVal) !== 0) {
-    return this.GetNumber(__privateGet(this, _pauseVal));
-  }
-  if (isNode) {
-    return this.GetNumber(performance.now() - __privateGet(this, _start));
-  } else {
-    return this.GetNumber(performance.now() - __privateGet(this, _start));
-  }
-};
-SetVal_fn4 = function(updatedValue) {
-  if (isNode) {
-    __privateSet(this, _start, performance.now() - updatedValue);
-  } else {
-    __privateSet(this, _start, performance.now() - updatedValue);
-  }
-};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -1439,7 +1338,7 @@ function requireTimsort$1() {
         }
         return offset;
       }
-      var TimSort = function() {
+      var TimSort = (function() {
         function TimSort2(array, compare) {
           _classCallCheck(this, TimSort2);
           this.array = null;
@@ -1767,7 +1666,7 @@ function requireTimsort$1() {
           }
         };
         return TimSort2;
-      }();
+      })();
       function sort(array, compare, lo, hi) {
         if (!Array.isArray(array)) {
           throw new TypeError("Can only sort arrays");
@@ -1888,69 +1787,57 @@ function requireLib() {
 var libExports = requireLib();
 const percentile = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
 class InstrumentGaugeOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "interval");
-    __publicField(this, "sampleSize");
-    __publicField(this, "fromJSON");
-    __publicField(this, "initValue");
-  }
+  interval;
+  sampleSize;
+  fromJSON;
+  initValue;
 }
 class InstrumentGaugeTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "val");
-    __publicField(this, "Inc");
-    __publicField(this, "Dec");
-  }
+  val;
+  Inc;
+  Dec;
 }
 class InstrumentGauge extends InstrumentBase {
+  #val = 0;
+  #maxval = null;
+  #lastObservedValue = 0;
+  #timeSeriesList = [];
+  #maxSampleSize = 0;
+  #timerInterval = 0;
+  #observer = null;
+  //@@ extras
+  #min = null;
+  #max = 0;
+  #observations = 0;
+  #total = 0;
+  #copy = false;
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentGauge_instances);
-    __privateAdd(this, _val3, 0);
-    __privateAdd(this, _maxval, null);
-    __privateAdd(this, _lastObservedValue, 0);
-    __privateAdd(this, _timeSeriesList, []);
-    __privateAdd(this, _maxSampleSize, 0);
-    __privateAdd(this, _timerInterval2, 0);
-    __privateAdd(this, _observer, null);
-    //@@ extras
-    __privateAdd(this, _min, null);
-    __privateAdd(this, _max, 0);
-    __privateAdd(this, _observations, 0);
-    __privateAdd(this, _total, 0);
-    __privateAdd(this, _copy5, false);
-    __publicField(this, "percentile");
-    __publicField(this, "min");
-    __publicField(this, "max");
-    __publicField(this, "avg");
-    __publicField(this, "val", 0);
     if (!options.label) {
       this.label = "InstrumentGauge";
     } else {
       this.label = options.label;
     }
     if (typeof options.interval === "undefined") {
-      __privateSet(this, _timerInterval2, 0);
+      this.#timerInterval = 0;
     } else {
-      __privateSet(this, _timerInterval2, options.interval);
+      this.#timerInterval = options.interval;
     }
     if (typeof options.sampleSize === "undefined") {
-      __privateSet(this, _maxSampleSize, 600);
+      this.#maxSampleSize = 600;
     } else {
-      __privateSet(this, _maxSampleSize, options.sampleSize);
+      this.#maxSampleSize = options.sampleSize;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy5, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy5, true);
+      this.#copy = true;
     }
     Object.defineProperty(this, GaugeTypes.GAUGE_TYPE, {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_GAUGE
     });
-    if (__privateGet(this, _copy5)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val",
         "min",
@@ -1961,15 +1848,15 @@ class InstrumentGauge extends InstrumentBase {
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentGauge_instances, GetVal_fn5).call(this),
+        get: () => this.#GetVal(),
         set: (value) => {
-          __privateMethod(this, _InstrumentGauge_instances, SetVal_fn5).call(this, value);
+          this.#SetVal(value);
         }
       });
-      if (__privateGet(this, _timerInterval2) > 0) {
+      if (this.#timerInterval > 0) {
         Object.defineProperty(this, "percentile", {
           enumerable: true,
-          get: () => __privateMethod(this, _InstrumentGauge_instances, GetPercentileData_fn).call(this)
+          get: () => this.#GetPercentileData()
         });
         this._StartTimer();
       }
@@ -1994,6 +1881,11 @@ class InstrumentGauge extends InstrumentBase {
       }
     }
   }
+  percentile;
+  min;
+  max;
+  avg;
+  val = 0;
   WithInitVal(initVal) {
     this.val = initVal;
     return this;
@@ -2001,66 +1893,134 @@ class InstrumentGauge extends InstrumentBase {
   WithMin() {
     Object.defineProperty(this, "min", {
       enumerable: true,
-      get: () => __privateMethod(this, _InstrumentGauge_instances, GetMin_fn).call(this)
+      get: () => this.#GetMin()
     });
     return this;
   }
   WithMax() {
     Object.defineProperty(this, "max", {
       enumerable: true,
-      get: () => __privateMethod(this, _InstrumentGauge_instances, GetMax_fn).call(this)
+      get: () => this.#GetMax()
     });
     return this;
   }
   WithAverage() {
     Object.defineProperty(this, "avg", {
       enumerable: true,
-      get: () => __privateMethod(this, _InstrumentGauge_instances, GetAverage_fn).call(this)
+      get: () => this.#GetAverage()
     });
     return this;
   }
   _StartTimer() {
-    if (__privateGet(this, _timerInterval2) > 0) {
-      __privateSet(this, _timeSeriesList, []);
-      __privateSet(this, _observer, setInterval(() => {
-        if (__privateGet(this, _timeSeriesList).length > __privateGet(this, _maxSampleSize)) {
-          __privateGet(this, _timeSeriesList).shift();
+    if (this.#timerInterval > 0) {
+      this.#timeSeriesList = [];
+      this.#observer = setInterval(() => {
+        if (this.#timeSeriesList.length > this.#maxSampleSize) {
+          this.#timeSeriesList.shift();
         }
-        const maxval = __privateMethod(this, _InstrumentGauge_instances, GetAndResetMaxVal_fn).call(this);
-        __privateGet(this, _timeSeriesList).push(maxval);
-      }, __privateGet(this, _timerInterval2)));
+        const maxval = this.#GetAndResetMaxVal();
+        this.#timeSeriesList.push(maxval);
+      }, this.#timerInterval);
       if (isNode) {
-        __privateGet(this, _observer).unref();
+        this.#observer.unref();
       }
     } else {
       throw new Error(`Unable to StartTimer for this instrument. The interval is set to <= 0.`);
     }
   }
   StopTimer() {
-    if (__privateGet(this, _observer)) {
-      clearTimeout(__privateGet(this, _observer));
-      __privateSet(this, _observer, null);
-      __privateSet(this, _timeSeriesList, []);
+    if (this.#observer) {
+      clearTimeout(this.#observer);
+      this.#observer = null;
+      this.#timeSeriesList = [];
+    }
+  }
+  /**
+  * If the gauge is being monitored as part of a time series, get the most recent recorded value (max value) from within the time interval
+  * otherwise, just return the current instant value.
+  */
+  #GetVal() {
+    if (this.#timerInterval > 0 && this.#observer !== null) {
+      if (this.#maxval === null) {
+        return this.GetNumber(this.#lastObservedValue);
+      } else {
+        return this.GetNumber(this.#maxval);
+      }
+    }
+    return this.GetNumber(this.#val);
+  }
+  #SetVal(updatedValue) {
+    this.#val = updatedValue;
+    this.#observations++;
+    this.#total += updatedValue;
+    if (this.#val > this.#max) {
+      this.#max = this.#val;
+    }
+    if (this.#min !== null) {
+      if (this.#val < this.#min) {
+        this.#min = this.#val;
+      }
+    } else {
+      this.#min = this.#val;
+    }
+    if (this.#timerInterval > 0) {
+      this.#lastObservedValue = updatedValue;
+      if (this.#maxval === null) {
+        this.#maxval = this.#val;
+      } else if (this.#val > this.#maxval) {
+        this.#maxval = this.#val;
+      }
+    }
+  }
+  #GetMin() {
+    if (this.#min !== null) {
+      return this.#min;
     }
+    return 0;
+  }
+  #GetMax() {
+    return this.#max;
+  }
+  #GetAverage() {
+    if (this.#observations > 0) {
+      return this.#total / this.#observations;
+    }
+    return 0;
   }
   Reset() {
     this.StopTimer();
-    __privateSet(this, _maxval, 0);
-    __privateSet(this, _lastObservedValue, 0);
-    __privateSet(this, _val3, 0);
-    __privateSet(this, _min, null);
-    __privateSet(this, _max, 0);
-    __privateSet(this, _observations, 0);
-    __privateSet(this, _total, 0);
-    if (__privateGet(this, _timerInterval2) > 0) {
+    this.#maxval = 0;
+    this.#lastObservedValue = 0;
+    this.#val = 0;
+    this.#min = null;
+    this.#max = 0;
+    this.#observations = 0;
+    this.#total = 0;
+    if (this.#timerInterval > 0) {
       this._StartTimer();
     }
   }
+  #GetAndResetMaxVal() {
+    if (this.#maxval === null) {
+      return this.#lastObservedValue;
+    }
+    const retVal = this.#maxval;
+    this.#maxval = null;
+    return retVal;
+  }
   Inc(incVal = 1) {
-    __privateMethod(this, _InstrumentGauge_instances, SetVal_fn5).call(this, __privateGet(this, _val3) + incVal);
+    this.#SetVal(this.#val + incVal);
   }
   Dec(decVal = 1) {
-    __privateMethod(this, _InstrumentGauge_instances, SetVal_fn5).call(this, __privateGet(this, _val3) - decVal);
+    this.#SetVal(this.#val - decVal);
+  }
+  #NumberCompare(a, b) {
+    return a - b;
+  }
+  #GetPercentileData() {
+    const sortedList = this.#timeSeriesList.slice(0);
+    timsortExports.sort(sortedList, this.#NumberCompare);
+    return percentile([50, 80, 90, 95, 99, 99.95], sortedList);
   }
   ProcessTelemetry(telemetry) {
     if (telemetry.Inc !== void 0) {
@@ -2074,131 +2034,42 @@ class InstrumentGauge extends InstrumentBase {
     }
   }
 }
-_val3 = new WeakMap();
-_maxval = new WeakMap();
-_lastObservedValue = new WeakMap();
-_timeSeriesList = new WeakMap();
-_maxSampleSize = new WeakMap();
-_timerInterval2 = new WeakMap();
-_observer = new WeakMap();
-_min = new WeakMap();
-_max = new WeakMap();
-_observations = new WeakMap();
-_total = new WeakMap();
-_copy5 = new WeakMap();
-_InstrumentGauge_instances = new WeakSet();
-/**
-* If the gauge is being monitored as part of a time series, get the most recent recorded value (max value) from within the time interval
-* otherwise, just return the current instant value.
-*/
-GetVal_fn5 = function() {
-  if (__privateGet(this, _timerInterval2) > 0 && __privateGet(this, _observer) !== null) {
-    if (__privateGet(this, _maxval) === null) {
-      return this.GetNumber(__privateGet(this, _lastObservedValue));
-    } else {
-      return this.GetNumber(__privateGet(this, _maxval));
-    }
-  }
-  return this.GetNumber(__privateGet(this, _val3));
-};
-SetVal_fn5 = function(updatedValue) {
-  __privateSet(this, _val3, updatedValue);
-  __privateWrapper(this, _observations)._++;
-  __privateSet(this, _total, __privateGet(this, _total) + updatedValue);
-  if (__privateGet(this, _val3) > __privateGet(this, _max)) {
-    __privateSet(this, _max, __privateGet(this, _val3));
-  }
-  if (__privateGet(this, _min) !== null) {
-    if (__privateGet(this, _val3) < __privateGet(this, _min)) {
-      __privateSet(this, _min, __privateGet(this, _val3));
-    }
-  } else {
-    __privateSet(this, _min, __privateGet(this, _val3));
-  }
-  if (__privateGet(this, _timerInterval2) > 0) {
-    __privateSet(this, _lastObservedValue, updatedValue);
-    if (__privateGet(this, _maxval) === null) {
-      __privateSet(this, _maxval, __privateGet(this, _val3));
-    } else if (__privateGet(this, _val3) > __privateGet(this, _maxval)) {
-      __privateSet(this, _maxval, __privateGet(this, _val3));
-    }
-  }
-};
-GetMin_fn = function() {
-  if (__privateGet(this, _min) !== null) {
-    return __privateGet(this, _min);
-  }
-  return 0;
-};
-GetMax_fn = function() {
-  return __privateGet(this, _max);
-};
-GetAverage_fn = function() {
-  if (__privateGet(this, _observations) > 0) {
-    return __privateGet(this, _total) / __privateGet(this, _observations);
-  }
-  return 0;
-};
-GetAndResetMaxVal_fn = function() {
-  if (__privateGet(this, _maxval) === null) {
-    return __privateGet(this, _lastObservedValue);
-  }
-  const retVal = __privateGet(this, _maxval);
-  __privateSet(this, _maxval, null);
-  return retVal;
-};
-NumberCompare_fn = function(a, b) {
-  return a - b;
-};
-GetPercentileData_fn = function() {
-  const sortedList = __privateGet(this, _timeSeriesList).slice(0);
-  timsortExports.sort(sortedList, __privateMethod(this, _InstrumentGauge_instances, NumberCompare_fn));
-  return percentile([50, 80, 90, 95, 99, 99.95], sortedList);
-};
 class InstrumentObjectOptions extends InstrumentBaseOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "fromJSON");
-    __publicField(this, "initValue");
-  }
+  fromJSON;
+  initValue;
 }
 class InstrumentObjectTelemetry extends InstrumentBaseTelemetry {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "val");
-  }
+  val;
 }
 class InstrumentObject extends InstrumentBase {
+  #val = {};
+  #copy = false;
   constructor(options = {}) {
     super(options);
-    __privateAdd(this, _InstrumentObject_instances);
-    __privateAdd(this, _val4, {});
-    __privateAdd(this, _copy6, false);
-    __publicField(this, "val");
     if (typeof options.label === "undefined") {
       this.label = "InstrumentObject";
     } else {
       this.label = options.label;
     }
     if (typeof options.fromJSON === "undefined") {
-      __privateSet(this, _copy6, false);
+      this.#copy = false;
     } else {
-      __privateSet(this, _copy6, true);
+      this.#copy = true;
     }
     Object.defineProperty(this, GaugeTypes.GAUGE_TYPE, {
       enumerable: true,
       get: () => GaugeTypes.INSTRUMENT_OBJECT
     });
-    if (__privateGet(this, _copy6)) {
+    if (this.#copy) {
       this.DefineCopyProperties([
         "val"
       ]);
     } else {
       Object.defineProperty(this, "val", {
         enumerable: true,
-        get: () => __privateMethod(this, _InstrumentObject_instances, GetVal_fn6).call(this),
+        get: () => this.#GetVal(),
         set: (value) => {
-          __privateMethod(this, _InstrumentObject_instances, SetVal_fn6).call(this, value);
+          this.#SetVal(value);
         }
       });
     }
@@ -2212,25 +2083,23 @@ class InstrumentObject extends InstrumentBase {
       this.val = result.val;
     }
   }
+  val;
   WithInitVal(initVal) {
     this.val = initVal;
     return this;
   }
+  #GetVal() {
+    return this.#val;
+  }
+  #SetVal(updatedValue) {
+    this.#val = updatedValue;
+  }
   ProcessTelemetry(telemetry) {
     if (telemetry.val !== void 0) {
       this.val = telemetry.val;
     }
   }
 }
-_val4 = new WeakMap();
-_copy6 = new WeakMap();
-_InstrumentObject_instances = new WeakSet();
-GetVal_fn6 = function() {
-  return __privateGet(this, _val4);
-};
-SetVal_fn6 = function(updatedValue) {
-  __privateSet(this, _val4, updatedValue);
-};
 function CreateInstrument(sourceInstrument) {
   switch (sourceInstrument[GaugeTypes.GAUGE_TYPE]) {
     case GaugeTypes.INSTRUMENT_GAUGE:
@@ -2428,71 +2297,69 @@ var RequestLoggerMiddlewareEventName = /* @__PURE__ */ ((RequestLoggerMiddleware
   return RequestLoggerMiddlewareEventName2;
 })(RequestLoggerMiddlewareEventName || {});
 class RequestLoggerMiddleware extends STSOptionsBase {
+  #tinyEmitter = new TinyEmitter();
   constructor(options) {
     super(options);
-    __privateAdd(this, _tinyEmitter, new TinyEmitter());
-    __privateAdd(this, _RequestCompleted, (start) => {
-      __privateGet(this, _tinyEmitter).emit(
-        "UpdateInstrument_AR_DEC"
-        /* UpdateInstrument_AR_DEC */
-      );
-      let timeInMs = 0;
-      const end = process.hrtime(start);
-      timeInMs = (end[0] * 1e9 + end[1]) / 1e6;
-      timeInMs = parseFloat(timeInMs.toFixed(4));
-      __privateGet(this, _tinyEmitter).emit("UpdateInstrument_DH_VAL", timeInMs);
-      __privateGet(this, _tinyEmitter).emit("UpdateInstrument_D_VAL", timeInMs);
-    });
-    // https://stackoverflow.com/questions/18031839/how-to-use-process-hrtime-to-get-execution-time-of-async-function/18031945
-    /**
-    * Use with .bind(class instance).
-    * Example;
-    * ---
-    * `let requestLoggerMiddleware = new RequestLoggerMiddleware();
-    * app.use(requestLoggerMiddleware.Middleware.bind(requestLoggerMiddleware));`
-    * @param {*} req 
-    * @param {*} res 
-    * @param {*} next 
-    * @returns 
-    */
-    __publicField(this, "Middleware", async (req, res, next) => {
-      if (this.options.ignoresocketio && req.originalUrl.includes("socket.io")) {
-        return;
-      }
-      const start = process.hrtime();
-      __privateGet(this, _tinyEmitter).emit(
-        "UpdateInstrument_AR_INC"
-        /* UpdateInstrument_AR_INC */
-      );
-      __privateGet(this, _tinyEmitter).emit(
-        "UpdateInstrument_RC_INC"
-        /* UpdateInstrument_RC_INC */
-      );
-      __privateGet(this, _tinyEmitter).emit(
-        "UpdateInstrument_V_INC"
-        /* UpdateInstrument_V_INC */
-      );
-      req.on("aborted", () => {
-      });
-      req.on("close", () => {
-        __privateGet(this, _RequestCompleted).call(this, start);
-      });
-      req.on("end", () => {
-      });
-      res.on("finish", () => {
-      });
-      next();
-    });
   }
   get options() {
     return super.options;
   }
   on(eventName, callBackFn) {
-    __privateGet(this, _tinyEmitter).on(eventName, callBackFn);
-  }
+    this.#tinyEmitter.on(eventName, callBackFn);
+  }
+  #RequestCompleted = (start) => {
+    this.#tinyEmitter.emit(
+      "UpdateInstrument_AR_DEC"
+      /* UpdateInstrument_AR_DEC */
+    );
+    let timeInMs = 0;
+    const end = process.hrtime(start);
+    timeInMs = (end[0] * 1e9 + end[1]) / 1e6;
+    timeInMs = parseFloat(timeInMs.toFixed(4));
+    this.#tinyEmitter.emit("UpdateInstrument_DH_VAL", timeInMs);
+    this.#tinyEmitter.emit("UpdateInstrument_D_VAL", timeInMs);
+  };
+  // https://stackoverflow.com/questions/18031839/how-to-use-process-hrtime-to-get-execution-time-of-async-function/18031945
+  /**
+  * Use with .bind(class instance).
+  * Example;
+  * ---
+  * `let requestLoggerMiddleware = new RequestLoggerMiddleware();
+  * app.use(requestLoggerMiddleware.Middleware.bind(requestLoggerMiddleware));`
+  * @param {*} req 
+  * @param {*} res 
+  * @param {*} next 
+  * @returns 
+  */
+  Middleware = async (req, res, next) => {
+    if (this.options.ignoresocketio && req.originalUrl.includes("socket.io")) {
+      return;
+    }
+    const start = process.hrtime();
+    this.#tinyEmitter.emit(
+      "UpdateInstrument_AR_INC"
+      /* UpdateInstrument_AR_INC */
+    );
+    this.#tinyEmitter.emit(
+      "UpdateInstrument_RC_INC"
+      /* UpdateInstrument_RC_INC */
+    );
+    this.#tinyEmitter.emit(
+      "UpdateInstrument_V_INC"
+      /* UpdateInstrument_V_INC */
+    );
+    req.on("aborted", () => {
+    });
+    req.on("close", () => {
+      this.#RequestCompleted(start);
+    });
+    req.on("end", () => {
+    });
+    res.on("finish", () => {
+    });
+    next();
+  };
 }
-_tinyEmitter = new WeakMap();
-_RequestCompleted = new WeakMap();
 var ansiStyles = { exports: {} };
 var colorName;
 var hasRequiredColorName;
@@ -4206,15 +4073,15 @@ const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
 class Encoder {
   constructor(options) {
     this.entered = false;
-    this.extensionCodec = (options == null ? void 0 : options.extensionCodec) ?? ExtensionCodec.defaultCodec;
-    this.context = options == null ? void 0 : options.context;
-    this.useBigInt64 = (options == null ? void 0 : options.useBigInt64) ?? false;
-    this.maxDepth = (options == null ? void 0 : options.maxDepth) ?? DEFAULT_MAX_DEPTH;
-    this.initialBufferSize = (options == null ? void 0 : options.initialBufferSize) ?? DEFAULT_INITIAL_BUFFER_SIZE;
-    this.sortKeys = (options == null ? void 0 : options.sortKeys) ?? false;
-    this.forceFloat32 = (options == null ? void 0 : options.forceFloat32) ?? false;
-    this.ignoreUndefined = (options == null ? void 0 : options.ignoreUndefined) ?? false;
-    this.forceIntegerToFloat = (options == null ? void 0 : options.forceIntegerToFloat) ?? false;
+    this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+    this.context = options?.context;
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+    this.sortKeys = options?.sortKeys ?? false;
+    this.forceFloat32 = options?.forceFloat32 ?? false;
+    this.ignoreUndefined = options?.ignoreUndefined ?? false;
+    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
     this.pos = 0;
     this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
     this.bytes = new Uint8Array(this.view.buffer);
@@ -4597,58 +4464,58 @@ function encode(value, options) {
 class PublishTransportRESTServer extends STSOptionsBase {
   constructor(options) {
     super(options);
-    // Returns true for success or false for failure.
-    __publicField(this, "Publish", async (payload) => {
-      try {
-        if (this.options.showPublishPayload) {
-          console.log(chalk.grey(`PublishTransportRESTServer::Publish() url: [${this.options.url}]`));
-          console.log(payload);
-        }
-        const encodedData = encode(payload, { ignoreUndefined: true });
-        const headers = { "Content-Type": "application/octet-stream" };
-        let retVal = null;
-        if (this.options.socketPath) {
-          retVal = await axios({
-            method: "post",
-            data: Buffer.from(encodedData),
-            headers,
-            socketPath: this.options.socketPath
-          });
-        } else {
-          if (isNode) {
-            if (this.options.agentManager) {
-              retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(Buffer.from(encodedData)).withAgentManager(this.options.agentManager).config);
-            } else {
-              retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(Buffer.from(encodedData)).config);
-            }
+  }
+  get options() {
+    return super.options;
+  }
+  // Returns true for success or false for failure.
+  Publish = async (payload) => {
+    try {
+      if (this.options.showPublishPayload) {
+        console.log(chalk.grey(`PublishTransportRESTServer::Publish() url: [${this.options.url}]`));
+        console.log(payload);
+      }
+      const encodedData = encode(payload, { ignoreUndefined: true });
+      const headers = { "Content-Type": "application/octet-stream" };
+      let retVal = null;
+      if (this.options.socketPath) {
+        retVal = await axios({
+          method: "post",
+          data: Buffer.from(encodedData),
+          headers,
+          socketPath: this.options.socketPath
+        });
+      } else {
+        if (isNode) {
+          if (this.options.agentManager) {
+            retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(Buffer.from(encodedData)).withAgentManager(this.options.agentManager).config);
           } else {
-            const blob = new Blob([new Uint8Array(encodedData)], { type: "application/octet-stream" });
-            retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(blob).config);
-          }
-        }
-        if (retVal.status !== 200) {
-          if (this.options.showPublishPayload) {
-            console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
+            retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(Buffer.from(encodedData)).config);
           }
-          this.options.logger.debug(chalk.red(`Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
-          return false;
         } else {
-          if (this.options.showPublishPayload) {
-            console.log(chalk.grey(`PublishTransportRESTServer::Publish() _PerformPublishRESTAPI:_PerformPublish:#publishmessage: [${this.options.url}] - Valid response from server: [${retVal.status}]`));
-          }
+          const blob = new Blob([new Uint8Array(encodedData)], { type: "application/octet-stream" });
+          retVal = await axios(new STSAxiosConfig(this.options.url, "post", headers).withData(blob).config);
         }
-        return true;
-      } catch (error) {
+      }
+      if (retVal.status !== 200) {
         if (this.options.showPublishPayload) {
-          console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (PublishRESTServer:_PerformPublishRESTAPI:Error: [${error}]`));
+          console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
         }
+        this.options.logger.debug(chalk.red(`Error (_PerformPublishRESTAPI:_PerformPublish:#publishmessage): Invalid response from server: [${retVal.status}]`));
         return false;
+      } else {
+        if (this.options.showPublishPayload) {
+          console.log(chalk.grey(`PublishTransportRESTServer::Publish() _PerformPublishRESTAPI:_PerformPublish:#publishmessage: [${this.options.url}] - Valid response from server: [${retVal.status}]`));
+        }
       }
-    });
-  }
-  get options() {
-    return super.options;
-  }
+      return true;
+    } catch (error) {
+      if (this.options.showPublishPayload) {
+        console.log(chalk.red(`PublishTransportRESTServer::Publish() Error (PublishRESTServer:_PerformPublishRESTAPI:Error: [${error}]`));
+      }
+      return false;
+    }
+  };
   async Close() {
     if (this.options.agentManager) {
       this.options.agentManager.Terminate();
@@ -4657,115 +4524,103 @@ class PublishTransportRESTServer extends STSOptionsBase {
   }
 }
 class PublishInstruments extends STSOptionsBase {
+  #inPublish = false;
+  #observer = null;
+  #publishState = 0;
+  #publisherTransport = null;
   constructor(options) {
     super(options);
-    __privateAdd(this, _PublishInstruments_instances);
-    __privateAdd(this, _inPublish, false);
-    __privateAdd(this, _observer2, null);
-    __privateAdd(this, _publishState, 0);
-    __privateAdd(this, _publisherTransport, null);
-    __privateSet(this, _publisherTransport, null);
+    this.#publisherTransport = null;
     switch (options.publishTransportBaseOptions.transportType) {
       case TransportType.RESTAPI:
-        __privateSet(this, _publisherTransport, new PublishTransportRESTServer(options.publishTransportBaseOptions));
+        this.#publisherTransport = new PublishTransportRESTServer(options.publishTransportBaseOptions);
         break;
     }
-    __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 0, "constructor()");
+    this.#UpdateState(0, "constructor()");
   }
   get options() {
     return super.options;
   }
   async Publish() {
-    if (__privateGet(this, _inPublish)) {
+    if (this.#inPublish) {
       return false;
     }
-    if (__privateGet(this, _publisherTransport)) {
+    if (this.#publisherTransport) {
       try {
-        __privateSet(this, _inPublish, true);
+        this.#inPublish = true;
         if (this.options.publishInstrumentController) {
           const instrumentPayload = this.options.publishInstrumentController.GetPayloadData();
-          return await __privateGet(this, _publisherTransport).Publish(instrumentPayload);
+          return await this.#publisherTransport.Publish(instrumentPayload);
         }
         return false;
       } catch (error) {
         return false;
       } finally {
-        __privateSet(this, _inPublish, false);
+        this.#inPublish = false;
       }
     } else {
       return false;
     }
   }
+  #PublishTimeoutLoop(publishInterval) {
+    this.#observer = setTimeout(async () => {
+      const start = performance.now();
+      const result = await this.Publish();
+      const end = performance.now();
+      const diff = end - start;
+      if (this.#publishState === 1) {
+        if (result === true) {
+          this.#PublishTimeoutLoop(this.options.publishInterval - diff);
+        } else {
+          this.#PublishTimeoutLoop(this.options.publishPostFailInterval - diff);
+        }
+      }
+    }, publishInterval);
+    if (isNode) this.#observer.unref();
+  }
   async StartPublish() {
-    if (__privateGet(this, _publishState) !== 0) {
-      this.options.logger.debug(chalk.yellow(`StartPublish:${this.options.processContext.nid}: StartPublish called when not currently in the init state. Current State: [${__privateGet(this, _publishState)}]`));
+    if (this.#publishState !== 0) {
+      this.options.logger.debug(chalk.yellow(`StartPublish:${this.options.processContext.nid}: StartPublish called when not currently in the init state. Current State: [${this.#publishState}]`));
       return false;
     }
-    __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 1, "StartPublish()");
-    __privateMethod(this, _PublishInstruments_instances, PublishTimeoutLoop_fn).call(this, this.options.publishInterval);
+    this.#UpdateState(1, "StartPublish()");
+    this.#PublishTimeoutLoop(this.options.publishInterval);
     return true;
   }
+  #UpdateState(newState, comment) {
+    const previousState = this.#publishState;
+    this.#publishState = newState;
+    this.options.logger.debug(chalk.yellow(`#UpdateState:${this.options.processContext.nid}: Previous State: [${previousState}]. Current State: [${this.#publishState}]. Comment: [${comment}]`));
+  }
   async EndPublish() {
-    if (__privateGet(this, _publishState) !== 1) {
-      this.options.logger.debug(chalk.yellow(`EndPublish:${this.options.processContext.nid}: EndPublish called when not within the started state. Current State: [${__privateGet(this, _publishState)}]`));
+    if (this.#publishState !== 1) {
+      this.options.logger.debug(chalk.yellow(`EndPublish:${this.options.processContext.nid}: EndPublish called when not within the started state. Current State: [${this.#publishState}]`));
       return false;
     }
-    __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 2, "EndPublish() (1)");
-    if (__privateGet(this, _observer2) !== null) {
-      clearTimeout(__privateGet(this, _observer2));
-      __privateSet(this, _observer2, null);
+    this.#UpdateState(2, "EndPublish() (1)");
+    if (this.#observer !== null) {
+      clearTimeout(this.#observer);
+      this.#observer = null;
       await this.Publish();
     }
-    if (__privateGet(this, _publisherTransport)) {
-      await __privateGet(this, _publisherTransport).Close();
+    if (this.#publisherTransport) {
+      await this.#publisherTransport.Close();
     }
-    __privateMethod(this, _PublishInstruments_instances, UpdateState_fn).call(this, 0, "EndPublish() (2)");
+    this.#UpdateState(0, "EndPublish() (2)");
     return true;
   }
 }
-_inPublish = new WeakMap();
-_observer2 = new WeakMap();
-_publishState = new WeakMap();
-_publisherTransport = new WeakMap();
-_PublishInstruments_instances = new WeakSet();
-PublishTimeoutLoop_fn = function(publishInterval) {
-  __privateSet(this, _observer2, setTimeout(async () => {
-    const start = performance.now();
-    const result = await this.Publish();
-    const end = performance.now();
-    const diff = end - start;
-    if (__privateGet(this, _publishState) === 1) {
-      if (result === true) {
-        __privateMethod(this, _PublishInstruments_instances, PublishTimeoutLoop_fn).call(this, this.options.publishInterval - diff);
-      } else {
-        __privateMethod(this, _PublishInstruments_instances, PublishTimeoutLoop_fn).call(this, this.options.publishPostFailInterval - diff);
-      }
-    }
-  }, publishInterval));
-  if (isNode) __privateGet(this, _observer2).unref();
-};
-UpdateState_fn = function(newState, comment) {
-  const previousState = __privateGet(this, _publishState);
-  __privateSet(this, _publishState, newState);
-  this.options.logger.debug(chalk.yellow(`#UpdateState:${this.options.processContext.nid}: Previous State: [${previousState}]. Current State: [${__privateGet(this, _publishState)}]. Comment: [${comment}]`));
-};
 var ePublishState = /* @__PURE__ */ ((ePublishState2) => {
   ePublishState2[ePublishState2["init"] = 0] = "init";
   ePublishState2[ePublishState2["started"] = 1] = "started";
   ePublishState2[ePublishState2["stopping"] = 2] = "stopping";
   return ePublishState2;
 })(ePublishState || {});
-const _PublishInstrumentController = class _PublishInstrumentController extends STSOptionsBase {
+class PublishInstrumentController extends STSOptionsBase {
+  #instruments = {};
+  #publisher = null;
   constructor(options) {
     super(options);
-    __privateAdd(this, _PublishInstrumentController_instances);
-    __privateAdd(this, _instruments, {});
-    __privateAdd(this, _publisher, null);
-    __publicField(this, "LogEx", (message) => {
-      this.UpdateInstrument(Gauge.LOGGER, {
-        LogMessage: message
-      });
-    });
     this.SetupInstrumentation();
     const publishInstrumentsOptions = {
       logger: options.logger,
@@ -4775,7 +4630,7 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
       publishInstrumentController: this,
       publishTransportBaseOptions: { ...options.publishTransportBaseOptions }
     };
-    __privateSet(this, _publisher, new PublishInstruments(publishInstrumentsOptions));
+    this.#publisher = new PublishInstruments(publishInstrumentsOptions);
     if (this.options.autoStart === true) {
       this.StartPublish();
     }
@@ -4784,17 +4639,67 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
     return super.options;
   }
   async StartPublish() {
-    return __privateGet(this, _publisher).StartPublish();
+    return this.#publisher.StartPublish();
   }
   async EndPublish() {
-    return __privateGet(this, _publisher).EndPublish();
+    return this.#publisher.EndPublish();
   }
   async Publish() {
-    return __privateGet(this, _publisher).Publish();
+    return this.#publisher.Publish();
+  }
+  LogEx = (message) => {
+    this.UpdateInstrument(Gauge.LOGGER, {
+      LogMessage: message
+    });
+  };
+  #GetInstrument(instrumentName) {
+    return this.#instruments[instrumentName];
+  }
+  #ProcessTelemetryCommand(instrumentName, telemetry) {
+    const instrument = this.#GetInstrument(instrumentName);
+    if (instrument) {
+      instrument.ProcessTelemetry(telemetry);
+    }
+  }
+  // Instrument factory
+  #CreateInstrument(instrumentType, options) {
+    let instrument;
+    switch (instrumentType) {
+      case GaugeTypes.INSTRUMENT_GAUGE:
+        instrument = new InstrumentGauge(options);
+        break;
+      case GaugeTypes.INSTRUMENT_HISTOGRAM:
+        instrument = new InstrumentHistogram(options);
+        break;
+      case GaugeTypes.INSTRUMENT_LOG:
+        instrument = new InstrumentLog(options);
+        break;
+      case GaugeTypes.INSTRUMENT_OBJECT:
+        instrument = new InstrumentObject(options);
+        break;
+      case GaugeTypes.INSTRUMENT_TIMER:
+        instrument = new InstrumentTimerGauge(options);
+        break;
+      case GaugeTypes.INSTRUMENT_VELOCITY:
+        instrument = new InstrumentVelocity(options);
+        break;
+      default:
+        throw new Error(`Gauge type: [${instrumentType} not known.]`);
+    }
+    return instrument;
+  }
+  #CreateInstruments(payload) {
+    payload.forEach((instrumentDefinition) => {
+      const g = instrumentDefinition[0];
+      const gt = instrumentDefinition[1];
+      const instrumentBaseOptions = instrumentDefinition[2];
+      const instrument = this.#CreateInstrument(gt, instrumentBaseOptions);
+      this.#instruments[g] = instrument;
+    });
   }
   GetPayloadData() {
     const context = this.options.processContext;
-    const instruments = __privateGet(this, _instruments);
+    const instruments = this.#instruments;
     const payloadInstruments = {};
     for (const [key, value] of Object.entries(instruments)) {
       if (value instanceof InstrumentLog) {
@@ -4817,7 +4722,7 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
       this.options.logger.debug(chalk.yellow(`SetupInstrumentation: No context defined within supplied options.`));
       return;
     }
-    __privateMethod(this, _PublishInstrumentController_instances, CreateInstruments_fn).call(this, this.options.instrumentDefinitions);
+    this.#CreateInstruments(this.options.instrumentDefinitions);
   }
   /**
    * Check if an instrument exists within the managed instrument collection
@@ -4825,7 +4730,7 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
    * @returns 
    */
   InstrumentExists(instrumentName) {
-    if (__privateGet(this, _instruments)[instrumentName]) {
+    if (this.#instruments[instrumentName]) {
       return true;
     }
     return false;
@@ -4836,8 +4741,8 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
    * @param telemetry 
    */
   UpdateInstrument(instrumentName, telemetry) {
-    if (__privateGet(this, _instruments)[instrumentName]) {
-      __privateMethod(this, _PublishInstrumentController_instances, ProcessTelemetryCommand_fn).call(this, instrumentName, telemetry);
+    if (this.#instruments[instrumentName]) {
+      this.#ProcessTelemetryCommand(instrumentName, telemetry);
     } else {
       this.options.logger.debug(chalk.red(`UpdateInstrument:${this.options.processContext.nid}: Attempted to UpdateInstrument before initialised.`));
     }
@@ -4850,58 +4755,9 @@ const _PublishInstrumentController = class _PublishInstrumentController extends
   AddPublishInstrumentController(processContext) {
     const options = { ...this.options };
     options.processContext = processContext;
-    return new _PublishInstrumentController(options);
-  }
-};
-_instruments = new WeakMap();
-_publisher = new WeakMap();
-_PublishInstrumentController_instances = new WeakSet();
-GetInstrument_fn = function(instrumentName) {
-  return __privateGet(this, _instruments)[instrumentName];
-};
-ProcessTelemetryCommand_fn = function(instrumentName, telemetry) {
-  const instrument = __privateMethod(this, _PublishInstrumentController_instances, GetInstrument_fn).call(this, instrumentName);
-  if (instrument) {
-    instrument.ProcessTelemetry(telemetry);
-  }
-};
-// Instrument factory
-CreateInstrument_fn = function(instrumentType, options) {
-  let instrument;
-  switch (instrumentType) {
-    case GaugeTypes.INSTRUMENT_GAUGE:
-      instrument = new InstrumentGauge(options);
-      break;
-    case GaugeTypes.INSTRUMENT_HISTOGRAM:
-      instrument = new InstrumentHistogram(options);
-      break;
-    case GaugeTypes.INSTRUMENT_LOG:
-      instrument = new InstrumentLog(options);
-      break;
-    case GaugeTypes.INSTRUMENT_OBJECT:
-      instrument = new InstrumentObject(options);
-      break;
-    case GaugeTypes.INSTRUMENT_TIMER:
-      instrument = new InstrumentTimerGauge(options);
-      break;
-    case GaugeTypes.INSTRUMENT_VELOCITY:
-      instrument = new InstrumentVelocity(options);
-      break;
-    default:
-      throw new Error(`Gauge type: [${instrumentType} not known.]`);
+    return new PublishInstrumentController(options);
   }
-  return instrument;
-};
-CreateInstruments_fn = function(payload) {
-  payload.forEach((instrumentDefinition) => {
-    const g = instrumentDefinition[0];
-    const gt = instrumentDefinition[1];
-    const instrumentBaseOptions = instrumentDefinition[2];
-    const instrument = __privateMethod(this, _PublishInstrumentController_instances, CreateInstrument_fn).call(this, gt, instrumentBaseOptions);
-    __privateGet(this, _instruments)[g] = instrument;
-  });
-};
-let PublishInstrumentController = _PublishInstrumentController;
+}
 const STSInstrumentControllerPluginKey = Symbol("instrumentController");
 const GetSTSInstrumentControllerPluginKey = () => STSInstrumentControllerPluginKey;
 const CompareSTSInstrumentControllerPluginKey = (val) => val === STSInstrumentControllerPluginKey;
@@ -5271,7 +5127,7 @@ const GetInstruments = (service) => {
   });
   return retVal;
 };
-const _ObservabilityModelUtils = class _ObservabilityModelUtils {
+class ObservabilityModelUtils {
   static GetModelNode(data) {
     const fixedSize = 2;
     const padLength = 9;
@@ -5369,6 +5225,42 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
       };
     }
   }
+  static ParseModelNode = (model, data, parseLog, gaugeName, fieldName) => {
+    if (fieldName in data) {
+      model.instruments[gaugeName] = this.GetModelNode(data[fieldName]);
+    } else {
+      parseLog.push(`ObservabilityModelUtils:ParseModelNode(): Field not present: [${fieldName}], default to [0]`);
+      model.instruments[gaugeName] = this.GetModelNode(0);
+    }
+  };
+  static ParseModelNodeWithQuantile = (model, data, parseLog, gaugeName, fieldName, quantileFieldName) => {
+    if (fieldName in data && quantileFieldName in data) {
+      model.instruments[gaugeName] = this.GetModelNodeWithQuantile(data[fieldName], data[quantileFieldName]);
+    } else if (fieldName in data) {
+      const dataVal = data[fieldName];
+      parseLog.push(`ObservabilityModelUtils:ParseModelNodeWithQuantile(): QuantileFieldName not present: [${quantileFieldName}], default to [${dataVal},{}]`);
+      model.instruments[gaugeName] = this.GetModelNodeWithQuantile(dataVal, {});
+    } else {
+      parseLog.push(`ObservabilityModelUtils:ParseModelNodeWithQuantile():  Field not present: [${fieldName}], QuantileFieldName not present: [${quantileFieldName}], default to [0,{}]`);
+      model.instruments[gaugeName] = this.GetModelNodeWithQuantile(0, {});
+    }
+  };
+  static ParseModelNodeHisto = (model, data, parseLog, gaugeName, fieldName) => {
+    if (fieldName in data) {
+      model.instruments[gaugeName] = this.GetModelNodeHistFromInfluxData(data[fieldName]);
+    } else {
+      parseLog.push(`ObservabilityModelUtils:ParseModelNodeHisto(): Field not present: [${fieldName}], default to [{}]`);
+      model.instruments[gaugeName] = this.GetModelNodeHistFromInfluxData({});
+    }
+  };
+  static ParseModelNodeObject = (model, data, parseLog, gaugeName, fieldName) => {
+    if (fieldName in data) {
+      model.instruments[gaugeName] = this.GetModelNodeObject(data[fieldName]);
+    } else {
+      parseLog.push(`ObservabilityModelUtils:ParseModelNodeObject(): Field not present: [${fieldName}], default to [{}]`);
+      model.instruments[gaugeName] = this.GetModelNodeObject({});
+    }
+  };
   static GetModelData(serviceType, model, data, parseLog) {
     const fieldList = [
       ...globalServiceDefinitions.coreFieldList,
@@ -5376,14 +5268,14 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
     ];
     fieldList.forEach((field) => {
       if (field.quantile) {
-        _ObservabilityModelUtils.ParseModelNodeWithQuantile(model, data, parseLog, field.gauge, field.fieldName, `${field.fieldName}_quantile`);
+        ObservabilityModelUtils.ParseModelNodeWithQuantile(model, data, parseLog, field.gauge, field.fieldName, `${field.fieldName}_quantile`);
       } else if (field.gaugeType.localeCompare(GaugeTypes.INSTRUMENT_OBJECT) === 0) {
-        _ObservabilityModelUtils.ParseModelNodeObject(model, data, parseLog, field.gauge, field.fieldName);
+        ObservabilityModelUtils.ParseModelNodeObject(model, data, parseLog, field.gauge, field.fieldName);
       } else {
-        _ObservabilityModelUtils.ParseModelNode(model, data, parseLog, field.gauge, field.fieldName);
+        ObservabilityModelUtils.ParseModelNode(model, data, parseLog, field.gauge, field.fieldName);
       }
       if (field.histo) {
-        _ObservabilityModelUtils.ParseModelNodeHisto(model, data, parseLog, field.histoGauge, `${field.fieldName}_histo`);
+        ObservabilityModelUtils.ParseModelNodeHisto(model, data, parseLog, field.histoGauge, `${field.fieldName}_histo`);
       }
     });
   }
@@ -5396,7 +5288,7 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
       };
       this.GetModelData("service", model, data, parseLog);
       if (!subscribeToKafka) {
-        model.instruments[Gauge.LOGGER] = _ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
+        model.instruments[Gauge.LOGGER] = ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
       }
       if (parseLog.length > 0) {
         parseLog.forEach((logEntry) => logger.debug(logEntry));
@@ -5415,7 +5307,7 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
       };
       this.GetModelData("lambda", model, data, parseLog);
       if (!subscribeToKafka) {
-        model.instruments[Gauge.LOGGER] = _ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
+        model.instruments[Gauge.LOGGER] = ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
       }
       if (parseLog.length > 0) {
         parseLog.forEach((logEntry) => logger.debug(logEntry));
@@ -5437,7 +5329,7 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
       };
       this.GetModelData("agent", model, data, parseLog);
       if (!subscribeToKafka) {
-        model.instruments[Gauge.LOGGER] = _ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
+        model.instruments[Gauge.LOGGER] = ObservabilityModelUtils.GetModelNodeRawStringArray(data["logMessages"]);
       }
       if (parseLog.length > 0) {
         parseLog.forEach((logEntry) => logger.debug(logEntry));
@@ -5447,112 +5339,63 @@ const _ObservabilityModelUtils = class _ObservabilityModelUtils {
       return null;
     }
   }
-};
-__publicField(_ObservabilityModelUtils, "ParseModelNode", (model, data, parseLog, gaugeName, fieldName) => {
-  if (fieldName in data) {
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNode(data[fieldName]);
-  } else {
-    parseLog.push(`ObservabilityModelUtils:ParseModelNode(): Field not present: [${fieldName}], default to [0]`);
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNode(0);
-  }
-});
-__publicField(_ObservabilityModelUtils, "ParseModelNodeWithQuantile", (model, data, parseLog, gaugeName, fieldName, quantileFieldName) => {
-  if (fieldName in data && quantileFieldName in data) {
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeWithQuantile(data[fieldName], data[quantileFieldName]);
-  } else if (fieldName in data) {
-    const dataVal = data[fieldName];
-    parseLog.push(`ObservabilityModelUtils:ParseModelNodeWithQuantile(): QuantileFieldName not present: [${quantileFieldName}], default to [${dataVal},{}]`);
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeWithQuantile(dataVal, {});
-  } else {
-    parseLog.push(`ObservabilityModelUtils:ParseModelNodeWithQuantile():  Field not present: [${fieldName}], QuantileFieldName not present: [${quantileFieldName}], default to [0,{}]`);
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeWithQuantile(0, {});
-  }
-});
-__publicField(_ObservabilityModelUtils, "ParseModelNodeHisto", (model, data, parseLog, gaugeName, fieldName) => {
-  if (fieldName in data) {
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeHistFromInfluxData(data[fieldName]);
-  } else {
-    parseLog.push(`ObservabilityModelUtils:ParseModelNodeHisto(): Field not present: [${fieldName}], default to [{}]`);
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeHistFromInfluxData({});
-  }
-});
-__publicField(_ObservabilityModelUtils, "ParseModelNodeObject", (model, data, parseLog, gaugeName, fieldName) => {
-  if (fieldName in data) {
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeObject(data[fieldName]);
-  } else {
-    parseLog.push(`ObservabilityModelUtils:ParseModelNodeObject(): Field not present: [${fieldName}], default to [{}]`);
-    model.instruments[gaugeName] = _ObservabilityModelUtils.GetModelNodeObject({});
-  }
-});
-let ObservabilityModelUtils = _ObservabilityModelUtils;
+}
 class KafkaHelper {
+  #kafkaLog = {};
+  #maxLogLength;
   constructor(options) {
-    __privateAdd(this, _kafkaLog, {});
-    __privateAdd(this, _maxLogLength);
-    __publicField(this, "GetKafkaLogData", (kafkaTopic, modelNode) => {
-      if (__privateGet(this, _kafkaLog)[kafkaTopic]) {
-        modelNode.instruments[Gauge.LOGGER] = ObservabilityModelUtils.GetModelNodeRawStringArray(__privateGet(this, _kafkaLog)[kafkaTopic].kafkaLog);
+    this.#maxLogLength = options.maxLogLength;
+  }
+  GetKafkaLogData = (kafkaTopic, modelNode) => {
+    if (this.#kafkaLog[kafkaTopic]) {
+      modelNode.instruments[Gauge.LOGGER] = ObservabilityModelUtils.GetModelNodeRawStringArray(this.#kafkaLog[kafkaTopic].kafkaLog);
+    }
+  };
+  ProcessKafkaData = (payload) => {
+    const { data } = payload;
+    if (data) {
+      const kafkaData = data;
+      const { kafkaTopic, value } = kafkaData;
+      if (!this.#kafkaLog[kafkaTopic]) {
+        this.#kafkaLog[kafkaTopic] = {
+          kafkaTopic: `${kafkaTopic}`,
+          //@@ why is this needed
+          kafkaLog: []
+        };
       }
-    });
-    __publicField(this, "ProcessKafkaData", (payload) => {
-      const { data } = payload;
-      if (data) {
-        const kafkaData = data;
-        const { kafkaTopic, value } = kafkaData;
-        if (!__privateGet(this, _kafkaLog)[kafkaTopic]) {
-          __privateGet(this, _kafkaLog)[kafkaTopic] = {
-            kafkaTopic: `${kafkaTopic}`,
-            //@@ why is this needed
-            kafkaLog: []
-          };
-        }
-        __privateGet(this, _kafkaLog)[kafkaTopic].kafkaLog.push(value);
-        while (__privateGet(this, _kafkaLog)[kafkaTopic].kafkaLog.length > __privateGet(this, _maxLogLength)) {
-          __privateGet(this, _kafkaLog)[kafkaTopic].kafkaLog.shift();
-        }
+      this.#kafkaLog[kafkaTopic].kafkaLog.push(value);
+      while (this.#kafkaLog[kafkaTopic].kafkaLog.length > this.#maxLogLength) {
+        this.#kafkaLog[kafkaTopic].kafkaLog.shift();
       }
-    });
-    __privateSet(this, _maxLogLength, options.maxLogLength);
-  }
+    }
+  };
 }
-_kafkaLog = new WeakMap();
-_maxLogLength = new WeakMap();
 class ObservabilityRESTAPISubscriber {
+  #socketSubscribeKeepAlive = {};
+  #options;
+  // This is required becuase each call to .bind create a new replica bound function - so we need the same instance for on/off event bindings.
+  KeepAliveAckBoundFunction;
   constructor(options) {
-    __privateAdd(this, _ObservabilityRESTAPISubscriber_instances);
-    __privateAdd(this, _socketSubscribeKeepAlive, {});
-    __privateAdd(this, _options2);
-    // This is required becuase each call to .bind create a new replica bound function - so we need the same instance for on/off event bindings.
-    __publicField(this, "KeepAliveAckBoundFunction");
-    __privateAdd(this, _GetData, async (subscription) => {
-      try {
-        const retVal = await __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, InvokeRESTAPI_fn).call(this, subscription);
-        if (retVal) {
-          const payload = {
-            subscriptionKey: subscription.subscriptionKey,
-            data: retVal
-          };
-          subscription.cb(payload);
-        }
-      } catch (error) {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subscription);
-      }
-    });
-    __privateSet(this, _options2, options);
+    this.#options = options;
+  }
+  #LogDebugMessage(message) {
+    this.#options.logger.debug(message);
+  }
+  #LogErrorMessage(message) {
+    this.#options.logger.error(message);
   }
   SubscribeOne(subscription) {
     this.Subscribe([subscription]);
   }
   async Subscribe(subscriptions) {
     subscriptions.map(async (subId) => {
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`ObservabilityRESTAPISubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      this.#RemoveKeepAlive(subId);
+      this.#LogDebugMessage(chalk.yellow(`ObservabilityRESTAPISubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, AddKeepAlive_fn).call(this, subId);
+        this.#AddKeepAlive(subId);
       } catch (error) {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
+        this.#LogErrorMessage(chalk.red(`ObservabilityRESTAPISubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
+        this.#RemoveKeepAlive(subId);
       }
     });
   }
@@ -5561,159 +5404,164 @@ class ObservabilityRESTAPISubscriber {
   }
   UnSubscribe(subscriptions) {
     subscriptions.map(async (subId) => {
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subId);
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`ObservabilityRESTAPISubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      this.#RemoveKeepAlive(subId);
+      this.#LogDebugMessage(chalk.yellow(`ObservabilityRESTAPISubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
     });
   }
-}
-_socketSubscribeKeepAlive = new WeakMap();
-_options2 = new WeakMap();
-_ObservabilityRESTAPISubscriber_instances = new WeakSet();
-LogDebugMessage_fn = function(message) {
-  __privateGet(this, _options2).logger.debug(message);
-};
-LogErrorMessage_fn = function(message) {
-  __privateGet(this, _options2).logger.error(message);
-};
-InvokeRESTAPI_fn = async function(subscription) {
-  const { subscriptionKey } = subscription;
-  let url = "";
-  switch (subscriptionKey.topic) {
-    // Services -------------------------------------------------------------------------------------------
-    case SubscriptionTopic.AllServicesCombined:
-      url = `/metrics`;
-      break;
-    case SubscriptionTopic.Services:
-      url = `/metrics/services`;
-      break;
-    case SubscriptionTopic.ServiceInstances:
-      if (subscriptionKey.key) {
-        url = `/metrics/services/${subscriptionKey.key}`;
+  async #InvokeRESTAPI(subscription) {
+    const { subscriptionKey } = subscription;
+    let url = "";
+    switch (subscriptionKey.topic) {
+      // Services -------------------------------------------------------------------------------------------
+      case SubscriptionTopic.AllServicesCombined:
+        url = `/metrics`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Services): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-      }
-    case SubscriptionTopic.ServiceInstance:
-      url = `/metrics/services/${subscriptionKey.key}`;
-      if (subscriptionKey.key && subscriptionKey.subkey) {
-        url = `/metrics/services/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+      case SubscriptionTopic.Services:
+        url = `/metrics/services`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Services): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-      }
-    // Lambdas -------------------------------------------------------------------------------------------
-    case SubscriptionTopic.AllLambdasCombined:
-      url = `/metrics`;
-      break;
-    case SubscriptionTopic.LambdaTechnologies:
-      url = `/metrics/lambdas`;
-      break;
-    case SubscriptionTopic.LambdaSubTechnologies:
-      if (subscriptionKey.key) {
-        url = `/metrics/lambdas/${subscriptionKey.key}`;
+      case SubscriptionTopic.ServiceInstances:
+        if (subscriptionKey.key) {
+          url = `/metrics/services/${subscriptionKey.key}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Services): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
+        }
+      case SubscriptionTopic.ServiceInstance:
+        url = `/metrics/services/${subscriptionKey.key}`;
+        if (subscriptionKey.key && subscriptionKey.subkey) {
+          url = `/metrics/services/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Services): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
+        }
+      // Lambdas -------------------------------------------------------------------------------------------
+      case SubscriptionTopic.AllLambdasCombined:
+        url = `/metrics`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Lambdas): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-      }
-    case SubscriptionTopic.LambdaSubTechnologiesInstance:
-      url = `/metrics/lambdas/${subscriptionKey.key}`;
-      if (subscriptionKey.key && subscriptionKey.subkey) {
-        url = `/metrics/lambdas/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+      case SubscriptionTopic.LambdaTechnologies:
+        url = `/metrics/lambdas`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Lambdas): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-      }
-    // User Agents -------------------------------------------------------------------------------------------
-    case SubscriptionTopic.AllAgentsCombined:
-      url = `/metrics`;
-      break;
-    case SubscriptionTopic.Agents:
-      url = `/metrics/agents`;
-      break;
-    case SubscriptionTopic.AgentWorkers:
-      if (subscriptionKey.key) {
-        url = `/metrics/agents/${subscriptionKey.key}`;
+      case SubscriptionTopic.LambdaSubTechnologies:
+        if (subscriptionKey.key) {
+          url = `/metrics/lambdas/${subscriptionKey.key}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Lambdas): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
+        }
+      case SubscriptionTopic.LambdaSubTechnologiesInstance:
+        url = `/metrics/lambdas/${subscriptionKey.key}`;
+        if (subscriptionKey.key && subscriptionKey.subkey) {
+          url = `/metrics/lambdas/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Lambdas): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
+        }
+      // User Agents -------------------------------------------------------------------------------------------
+      case SubscriptionTopic.AllAgentsCombined:
+        url = `/metrics`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Agents): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
-      }
-    case SubscriptionTopic.AgentWorker:
-      if (subscriptionKey.key && subscriptionKey.subkey) {
-        url = `/metrics/agents/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+      case SubscriptionTopic.Agents:
+        url = `/metrics/agents`;
         break;
-      } else {
-        throw new Error(`#OutputSubscription(Agents): key and/or subkey not provided for subscription: [${JSON.stringify(subscriptionKey.topic)}]`);
-      }
-  }
-  if (url.localeCompare("") !== 0) {
-    const endPointUrl = `${__privateGet(this, _options2).urlBase}${url}`;
-    let retVal;
-    const start = performance.now();
-    try {
-      if (isNode && __privateGet(this, _options2).agentManager) {
-        retVal = await axios(new STSAxiosConfig(endPointUrl, "get").withDefaultHeaders().withAgentManager(__privateGet(this, _options2).agentManager).config);
-      } else {
-        retVal = await axios(new STSAxiosConfig(endPointUrl, "get").withDefaultHeaders().config);
-      }
-      const end = performance.now();
-      const diff = end - start;
-      if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllServicesCombined) === 0) {
-        return retVal.data["services"].data;
-      }
-      if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllAgentsCombined) === 0) {
-        return retVal.data["agents"].data;
-      }
-      if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllLambdasCombined) === 0) {
-        return retVal.data["lambdas"].data;
-      }
-      return retVal.data;
-    } catch (error) {
-      return null;
+      case SubscriptionTopic.AgentWorkers:
+        if (subscriptionKey.key) {
+          url = `/metrics/agents/${subscriptionKey.key}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Agents): key not provided for subscription: [${JSON.stringify(subscriptionKey)}]`);
+        }
+      case SubscriptionTopic.AgentWorker:
+        if (subscriptionKey.key && subscriptionKey.subkey) {
+          url = `/metrics/agents/${subscriptionKey.key}/${subscriptionKey.subkey}`;
+          break;
+        } else {
+          throw new Error(`#OutputSubscription(Agents): key and/or subkey not provided for subscription: [${JSON.stringify(subscriptionKey.topic)}]`);
+        }
     }
-  } else {
-    return null;
-  }
-};
-_GetData = new WeakMap();
-SetupTimeout_fn = function(socketSubscribeKeepAlive, subscription, timeout) {
-  return setTimeout(async () => {
-    try {
+    if (url.localeCompare("") !== 0) {
+      const endPointUrl = `${this.#options.urlBase}${url}`;
+      let retVal;
       const start = performance.now();
-      await __privateGet(this, _GetData).call(this, subscription);
-      if (socketSubscribeKeepAlive.timeout) {
+      try {
+        if (isNode && this.#options.agentManager) {
+          retVal = await axios(new STSAxiosConfig(endPointUrl, "get").withDefaultHeaders().withAgentManager(this.#options.agentManager).config);
+        } else {
+          retVal = await axios(new STSAxiosConfig(endPointUrl, "get").withDefaultHeaders().config);
+        }
         const end = performance.now();
         const diff = end - start;
-        let timeoutDuration = __privateGet(this, _options2).keepAlive - diff;
-        if (timeoutDuration < 500) {
-          timeoutDuration = 500;
+        if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllServicesCombined) === 0) {
+          return retVal.data["services"].data;
         }
-        socketSubscribeKeepAlive.timeout = __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, SetupTimeout_fn).call(this, socketSubscribeKeepAlive, subscription, timeoutDuration);
-      } else {
-        __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.yellow(`Subscription removed: [${socketSubscribeKeepAlive.id}]. Processing terminate.`));
+        if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllAgentsCombined) === 0) {
+          return retVal.data["agents"].data;
+        }
+        if (subscriptionKey.topic.localeCompare(SubscriptionTopic.AllLambdasCombined) === 0) {
+          return retVal.data["lambdas"].data;
+        }
+        return retVal.data;
+      } catch (error) {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  #GetData = async (subscription) => {
+    try {
+      const retVal = await this.#InvokeRESTAPI(subscription);
+      if (retVal) {
+        const payload = {
+          subscriptionKey: subscription.subscriptionKey,
+          data: retVal
+        };
+        subscription.cb(payload);
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogErrorMessage_fn).call(this, chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
-      __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subscription);
+      this.#LogErrorMessage(chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+      this.#RemoveKeepAlive(subscription);
     }
-  }, timeout);
-};
-AddKeepAlive_fn = function(subscription) {
-  __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, RemoveKeepAlive_fn).call(this, subscription);
-  const socketSubscribeKeepAlive = {
-    id: subscription.subscriptionKey.id
   };
-  socketSubscribeKeepAlive.timeout = __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, SetupTimeout_fn).call(this, socketSubscribeKeepAlive, subscription, __privateGet(this, _options2).keepAlive);
-  __privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id] = socketSubscribeKeepAlive;
-  __privateGet(this, _GetData).call(this, subscription);
-};
-RemoveKeepAlive_fn = function(subscription) {
-  if (__privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id]) {
-    __privateMethod(this, _ObservabilityRESTAPISubscriber_instances, LogDebugMessage_fn).call(this, chalk.gray(`ObservabilityRESTAPISubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
-    clearTimeout(__privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id].timeout);
-    delete __privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id].timeout;
-    delete __privateGet(this, _socketSubscribeKeepAlive)[subscription.subscriptionKey.id];
+  #SetupTimeout(socketSubscribeKeepAlive, subscription, timeout) {
+    return setTimeout(async () => {
+      try {
+        const start = performance.now();
+        await this.#GetData(subscription);
+        if (socketSubscribeKeepAlive.timeout) {
+          const end = performance.now();
+          const diff = end - start;
+          let timeoutDuration = this.#options.keepAlive - diff;
+          if (timeoutDuration < 500) {
+            timeoutDuration = 500;
+          }
+          socketSubscribeKeepAlive.timeout = this.#SetupTimeout(socketSubscribeKeepAlive, subscription, timeoutDuration);
+        } else {
+          this.#LogDebugMessage(chalk.yellow(`Subscription removed: [${socketSubscribeKeepAlive.id}]. Processing terminate.`));
+        }
+      } catch (error) {
+        this.#LogErrorMessage(chalk.red(`ObservabilityRESTAPISubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+        this.#RemoveKeepAlive(subscription);
+      }
+    }, timeout);
   }
-};
+  #AddKeepAlive(subscription) {
+    this.#RemoveKeepAlive(subscription);
+    const socketSubscribeKeepAlive = {
+      id: subscription.subscriptionKey.id
+    };
+    socketSubscribeKeepAlive.timeout = this.#SetupTimeout(socketSubscribeKeepAlive, subscription, this.#options.keepAlive);
+    this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id] = socketSubscribeKeepAlive;
+    this.#GetData(subscription);
+  }
+  #RemoveKeepAlive(subscription) {
+    if (this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id]) {
+      this.#LogDebugMessage(chalk.gray(`ObservabilityRESTAPISubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
+      clearTimeout(this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id].timeout);
+      delete this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id].timeout;
+      delete this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id];
+    }
+  }
+}
 const byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -5734,13 +5582,9 @@ function rng() {
 }
 const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 const native = { randomUUID };
-function v4(options, buf, offset) {
-  var _a2;
-  if (native.randomUUID && true && !options) {
-    return native.randomUUID();
-  }
+function _v4(options, buf, offset) {
   options = options || {};
-  const rnds = options.random ?? ((_a2 = options.rng) == null ? void 0 : _a2.call(options)) ?? rng();
+  const rnds = options.random ?? options.rng?.() ?? rng();
   if (rnds.length < 16) {
     throw new Error("Random bytes length must be >= 16");
   }
@@ -5748,6 +5592,12 @@ function v4(options, buf, offset) {
   rnds[8] = rnds[8] & 63 | 128;
   return unsafeStringify(rnds);
 }
+function v4(options, buf, offset) {
+  if (native.randomUUID && true && !options) {
+    return native.randomUUID();
+  }
+  return _v4(options);
+}
 var messageStatus = /* @__PURE__ */ ((messageStatus2) => {
   messageStatus2["INPROGRESS"] = "INPROGRESS";
   messageStatus2["SUCCESS"] = "SUCCESS";
@@ -5764,68 +5614,73 @@ var messageStatusResponse = /* @__PURE__ */ ((messageStatusResponse2) => {
   return messageStatusResponse2;
 })(messageStatusResponse || {});
 class SocketIoMessageSender {
+  #messageWithAckPayloadRecords = {};
+  #socket;
+  #maxReties = 3;
+  //@@
+  #timeoutValue = 5e3;
+  //@@
+  #options;
+  #LogDebugMessage(message) {
+    this.#options.logger.debug(message);
+  }
   constructor(options) {
-    __privateAdd(this, _SocketIoMessageSender_instances);
-    __privateAdd(this, _messageWithAckPayloadRecords, {});
-    __privateAdd(this, _socket);
-    __privateAdd(this, _maxReties, 3);
-    //@@
-    __privateAdd(this, _timeoutValue, 5e3);
-    //@@
-    __privateAdd(this, _options3);
-    __privateSet(this, _options3, options);
-    __privateSet(this, _socket, options.socket);
+    this.#options = options;
+    this.#socket = options.socket;
   }
   get socket() {
-    return __privateGet(this, _socket);
+    return this.#socket;
   }
   set socket(socket) {
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.cyan(`SocketIoMessageSender:set socket(): new socket assigned`));
-    __privateSet(this, _socket, socket);
+    this.#LogDebugMessage(chalk.cyan(`SocketIoMessageSender:set socket(): new socket assigned`));
+    this.#socket = socket;
   }
   AckListener(message, payload) {
     if (message.subscriptionKey.id.localeCompare(payload.id) === 0) {
       clearTimeout(message.timeoutId);
       delete message.timeoutId;
-      __privateGet(this, _socket).off(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
+      this.#socket.off(this.#GetSubscribeKeepAliveAckEventName(message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
       message.endTime = performance.now();
       message.duration = message.endTime - message.startTime;
       message.status = "SUCCESS";
       message.subscriptionKeyResponse = payload;
-      delete __privateGet(this, _messageWithAckPayloadRecords)[message.id];
-      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.grey(`SocketIoMessageSender:AckListener(): ack received, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+      delete this.#messageWithAckPayloadRecords[message.id];
+      this.#LogDebugMessage(chalk.grey(`SocketIoMessageSender:AckListener(): ack received, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
       message.resolve(message);
     }
   }
   ResponseTimout(message) {
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached: [${__privateGet(this, _timeoutValue)}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    this.#LogDebugMessage(chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached: [${this.#timeoutValue}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
     delete message.timeoutId;
-    __privateGet(this, _socket).off(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
+    this.#socket.off(this.#GetSubscribeKeepAliveAckEventName(message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
     message.endTime = performance.now();
-    if (message.retryCount >= __privateGet(this, _maxReties)) {
+    if (message.retryCount >= this.#maxReties) {
       message.status = "FAIL";
-      __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.red(`SocketIoMessageSender:ResponseTimout(): timeout reached after ${__privateGet(this, _maxReties)} retries, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
-      delete __privateGet(this, _messageWithAckPayloadRecords)[message.id];
+      this.#LogDebugMessage(chalk.red(`SocketIoMessageSender:ResponseTimout(): timeout reached after ${this.#maxReties} retries, event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+      delete this.#messageWithAckPayloadRecords[message.id];
       message.reject(message);
       return;
     }
     message.status = "INRETRY";
     message.retryCount++;
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached, retrying. Retries: [${message.retryCount}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    this.#LogDebugMessage(chalk.magenta(`SocketIoMessageSender:ResponseTimout(): timeout reached, retrying. Retries: [${message.retryCount}], event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
     this.SendMessage(message);
   }
+  #GetSubscribeKeepAliveAckEventName(eventName, subscriptionKey) {
+    return `${eventName}Ack_${subscriptionKey.id}`;
+  }
   SendMessage(message) {
     message.startTime = performance.now();
     message.timeoutId = setTimeout(() => {
       this.ResponseTimout(message);
-    }, __privateGet(this, _timeoutValue));
+    }, this.#timeoutValue);
     const AckListenerCallback = (payload) => {
       this.AckListener(message, payload);
     };
     message.BoundAckListenerCallback = AckListenerCallback.bind(this);
-    __privateGet(this, _socket).on(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
-    __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.gray(`SocketIoMessageSender:SendMessage(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
-    __privateGet(this, _socket).emit(message.eventName, message.subscriptionKey);
+    this.#socket.on(this.#GetSubscribeKeepAliveAckEventName(message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
+    this.#LogDebugMessage(chalk.gray(`SocketIoMessageSender:SendMessage(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+    this.#socket.emit(message.eventName, message.subscriptionKey);
   }
   SendMessageWithAck(eventName, subscriptionKey) {
     const promise = new Promise((resolve, reject) => {
@@ -5839,82 +5694,75 @@ class SocketIoMessageSender {
         resolve,
         reject
       };
-      __privateGet(this, _messageWithAckPayloadRecords)[message.id] = message;
+      this.#messageWithAckPayloadRecords[message.id] = message;
       this.SendMessage(message);
     });
     return promise;
   }
   KillMessageInFlight(subscriptionKey) {
     const killIds = [];
-    for (const [, message] of Object.entries(__privateGet(this, _messageWithAckPayloadRecords))) {
+    for (const [, message] of Object.entries(this.#messageWithAckPayloadRecords)) {
       if (message.subscriptionKey.id.localeCompare(subscriptionKey.id) === 0) {
-        __privateMethod(this, _SocketIoMessageSender_instances, LogDebugMessage_fn2).call(this, chalk.blue(`SocketIoMessageSender:KillMessageInFlight(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
+        this.#LogDebugMessage(chalk.blue(`SocketIoMessageSender:KillMessageInFlight(): event: [${message.eventName}], subscriptionKey: [${message.subscriptionKey.id}]`));
         clearTimeout(message.timeoutId);
         delete message.timeoutId;
-        __privateGet(this, _socket).off(__privateMethod(this, _SocketIoMessageSender_instances, GetSubscribeKeepAliveAckEventName_fn).call(this, message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
+        this.#socket.off(this.#GetSubscribeKeepAliveAckEventName(message.eventName, message.subscriptionKey), message.BoundAckListenerCallback);
         killIds.push(message.id);
         message.status = "KILLED";
         message.reject(message);
       }
     }
     killIds.forEach((id) => {
-      delete __privateGet(this, _messageWithAckPayloadRecords)[id];
+      delete this.#messageWithAckPayloadRecords[id];
     });
   }
 }
-_messageWithAckPayloadRecords = new WeakMap();
-_socket = new WeakMap();
-_maxReties = new WeakMap();
-_timeoutValue = new WeakMap();
-_options3 = new WeakMap();
-_SocketIoMessageSender_instances = new WeakSet();
-LogDebugMessage_fn2 = function(message) {
-  __privateGet(this, _options3).logger.debug(message);
-};
-GetSubscribeKeepAliveAckEventName_fn = function(eventName, subscriptionKey) {
-  return `${eventName}Ack_${subscriptionKey.id}`;
-};
 class ObservabilitySocketIOSubscriber {
+  #socketSubscribeKeepAlive = {};
+  #socket;
+  #options;
+  #socketIoMessageSender;
+  // This is required becuase each call to .bind create a new replica bound function - so we need the same instance for on/off event bindings.
+  KeepAliveAckBoundFunction;
+  #LogDebugMessage(message) {
+    this.#options.logger.debug(message);
+  }
+  #LogErrorMessage(message) {
+    this.#options.logger.error(message);
+  }
   constructor(options) {
-    __privateAdd(this, _ObservabilitySocketIOSubscriber_instances);
-    __privateAdd(this, _socketSubscribeKeepAlive2, {});
-    __privateAdd(this, _socket2);
-    __privateAdd(this, _options4);
-    __privateAdd(this, _socketIoMessageSender);
-    // This is required becuase each call to .bind create a new replica bound function - so we need the same instance for on/off event bindings.
-    __publicField(this, "KeepAliveAckBoundFunction");
-    __privateSet(this, _options4, options);
-    __privateSet(this, _socket2, options.socket);
-    __privateSet(this, _socketIoMessageSender, new SocketIoMessageSender({
-      socket: __privateGet(this, _socket2),
-      logger: __privateGet(this, _options4).logger
-    }));
+    this.#options = options;
+    this.#socket = options.socket;
+    this.#socketIoMessageSender = new SocketIoMessageSender({
+      socket: this.#socket,
+      logger: this.#options.logger
+    });
   }
   get socket() {
-    return __privateGet(this, _socket2);
+    return this.#socket;
   }
   set socket(socket) {
-    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.cyan(`ObservabilitySocketIOSubscriber:set socket(): new socket assigned`));
-    __privateSet(this, _socket2, socket);
-    __privateGet(this, _socketIoMessageSender).socket = socket;
+    this.#LogDebugMessage(chalk.cyan(`ObservabilitySocketIOSubscriber:set socket(): new socket assigned`));
+    this.#socket = socket;
+    this.#socketIoMessageSender.socket = socket;
   }
   SubscribeOne(subscription) {
     this.Subscribe([subscription]);
   }
   async Subscribe(subscriptions) {
-    const socket = __privateGet(this, _socket2);
+    const socket = this.#socket;
     subscriptions.map(async (subId) => {
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      this.#RemoveKeepAlive(subId);
+      this.#LogDebugMessage(chalk.yellow(`ObservabilitySocketIOSubscriber:Subscribe(): Sending subscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
-        const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("subscribe", subId.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:Subscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, AddKeepAlive_fn2).call(this, socket, subId);
+        const retVal = await this.#socketIoMessageSender.SendMessageWithAck("subscribe", subId.subscriptionKey);
+        this.#LogDebugMessage(chalk.green(`ObservabilitySocketIOSubscriber:Subscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+        this.#AddKeepAlive(socket, subId);
         socket.on(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
       } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
+        this.#LogErrorMessage(chalk.red(`ObservabilitySocketIOSubscriber:Subscribe(): Error: response: [${JSON.stringify(error)}]`));
         socket.off(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
+        this.#RemoveKeepAlive(subId);
       }
     });
   }
@@ -5922,20 +5770,45 @@ class ObservabilitySocketIOSubscriber {
     this.UnSubscribe([subscription]);
   }
   UnSubscribe(subscriptions) {
-    const socket = __privateGet(this, _socket2);
+    const socket = this.#socket;
     subscriptions.map(async (subId) => {
       socket.off(GetSocketIOSubscriptionKey(subId.subscriptionKey), subId.cb);
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subId);
-      __privateGet(this, _socketIoMessageSender).KillMessageInFlight(subId.subscriptionKey);
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
+      this.#RemoveKeepAlive(subId);
+      this.#socketIoMessageSender.KillMessageInFlight(subId.subscriptionKey);
+      this.#LogDebugMessage(chalk.yellow(`ObservabilitySocketIOSubscriber:UnSubscribe(): Sending unsubscribe: subscriptionKey: [${subId.subscriptionKey.id}]`));
       try {
-        const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("unsubscribe", subId.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:UnSubscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+        const retVal = await this.#socketIoMessageSender.SendMessageWithAck("unsubscribe", subId.subscriptionKey);
+        this.#LogDebugMessage(chalk.green(`ObservabilitySocketIOSubscriber:UnSubscribe(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
       } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:UnSubscribe(): Error response: [${JSON.stringify(error)}]`));
+        this.#LogErrorMessage(chalk.red(`ObservabilitySocketIOSubscriber:UnSubscribe(): Error response: [${JSON.stringify(error)}]`));
       }
     });
   }
+  #AddKeepAlive(socket, subscription) {
+    this.#RemoveKeepAlive(subscription);
+    this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id] = {
+      id: subscription.subscriptionKey.id,
+      timeout: setTimeout(async () => {
+        this.#LogDebugMessage(chalk.yellow(`ObservabilitySocketIOSubscriber:#AddKeepAlive:timeoutCheck(): Sending keepAlive: subscriptionKey: [${subscription.subscriptionKey.id}]`));
+        try {
+          const retVal = await this.#socketIoMessageSender.SendMessageWithAck("subscribeKeepAlive", subscription.subscriptionKey);
+          this.#LogDebugMessage(chalk.green(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
+          this.#AddKeepAlive(socket, subscription);
+        } catch (error) {
+          this.#LogErrorMessage(chalk.red(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
+          socket.off(GetSocketIOSubscriptionKey(subscription.subscriptionKey), subscription.cb);
+          this.#RemoveKeepAlive(subscription);
+        }
+      }, this.#options.keepAlive)
+    };
+  }
+  #RemoveKeepAlive(subscription) {
+    if (this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id]) {
+      this.#LogDebugMessage(chalk.gray(`ObservabilitySocketIOSubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
+      clearTimeout(this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id].timeout);
+      delete this.#socketSubscribeKeepAlive[subscription.subscriptionKey.id];
+    }
+  }
   /*
   override SocketIOConnect(socket: Socket<ServerToClientEvents, ClientToServerEvents>): void {
       if (this.#observabilitySocketIOSubscriber instanceof ObservabilitySocketIOSubscriber) {
@@ -5950,124 +5823,89 @@ class ObservabilitySocketIOSubscriber {
   }
   */
 }
-_socketSubscribeKeepAlive2 = new WeakMap();
-_socket2 = new WeakMap();
-_options4 = new WeakMap();
-_socketIoMessageSender = new WeakMap();
-_ObservabilitySocketIOSubscriber_instances = new WeakSet();
-LogDebugMessage_fn3 = function(message) {
-  __privateGet(this, _options4).logger.debug(message);
-};
-LogErrorMessage_fn2 = function(message) {
-  __privateGet(this, _options4).logger.error(message);
-};
-AddKeepAlive_fn2 = function(socket, subscription) {
-  __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subscription);
-  __privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id] = {
-    id: subscription.subscriptionKey.id,
-    timeout: setTimeout(async () => {
-      __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.yellow(`ObservabilitySocketIOSubscriber:#AddKeepAlive:timeoutCheck(): Sending keepAlive: subscriptionKey: [${subscription.subscriptionKey.id}]`));
-      try {
-        const retVal = await __privateGet(this, _socketIoMessageSender).SendMessageWithAck("subscribeKeepAlive", subscription.subscriptionKey);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.green(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): SendMessageWithAck response: [${JSON.stringify(retVal)}]`));
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, AddKeepAlive_fn2).call(this, socket, subscription);
-      } catch (error) {
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogErrorMessage_fn2).call(this, chalk.red(`ObservabilitySocketIOSubscriber:#AddKeepAlive(): Error response: [${JSON.stringify(error)}]`));
-        socket.off(GetSocketIOSubscriptionKey(subscription.subscriptionKey), subscription.cb);
-        __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, RemoveKeepAlive_fn2).call(this, subscription);
-      }
-    }, __privateGet(this, _options4).keepAlive)
-  };
-};
-RemoveKeepAlive_fn2 = function(subscription) {
-  if (__privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id]) {
-    __privateMethod(this, _ObservabilitySocketIOSubscriber_instances, LogDebugMessage_fn3).call(this, chalk.gray(`ObservabilitySocketIOSubscriber:#RemoveKeepAlive(): subscriptionKey: [${subscription.subscriptionKey.id}]`));
-    clearTimeout(__privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id].timeout);
-    delete __privateGet(this, _socketSubscribeKeepAlive2)[subscription.subscriptionKey.id];
-  }
-};
 class ObservabilitySubscriptionManager {
+  #observabilitySocketIOSubscriber = null;
+  #subscriptions = [];
+  #kafkaHelper;
+  #serviceModel = {};
+  #agentModel = {};
+  #lambdaModel = {};
+  #options;
+  #LogDebugMessage(message) {
+    this.#options.logger.debug(message);
+  }
+  #LogErrorMessage(message) {
+    this.#options.logger.error(message);
+  }
   constructor(options) {
-    __privateAdd(this, _ObservabilitySubscriptionManager_instances);
-    __privateAdd(this, _observabilitySocketIOSubscriber, null);
-    __privateAdd(this, _subscriptions, []);
-    __privateAdd(this, _kafkaHelper);
-    __privateAdd(this, _serviceModel, {});
-    __privateAdd(this, _agentModel, {});
-    __privateAdd(this, _lambdaModel, {});
-    __privateAdd(this, _options5);
-    __privateSet(this, _options5, options);
-    __privateSet(this, _kafkaHelper, new KafkaHelper({
-      maxLogLength: __privateGet(this, _options5).maxLogLength
-    }));
+    this.#options = options;
+    this.#kafkaHelper = new KafkaHelper({
+      maxLogLength: this.#options.maxLogLength
+    });
   }
   get observabilitySocketIOSubscriber() {
-    return __privateGet(this, _observabilitySocketIOSubscriber);
+    return this.#observabilitySocketIOSubscriber;
   }
   set observabilitySocketIOSubscriber(observabilitySocketIOSubscriber) {
-    __privateSet(this, _observabilitySocketIOSubscriber, observabilitySocketIOSubscriber);
+    this.#observabilitySocketIOSubscriber = observabilitySocketIOSubscriber;
   }
   get subscriptions() {
-    return __privateGet(this, _subscriptions);
+    return this.#subscriptions;
   }
   set subscriptions(subscriptions) {
-    __privateSet(this, _subscriptions, subscriptions);
+    this.#subscriptions = subscriptions;
   }
   get serviceModel() {
-    return __privateGet(this, _serviceModel);
+    return this.#serviceModel;
   }
   get agentModel() {
-    return __privateGet(this, _agentModel);
+    return this.#agentModel;
   }
   get lambdaModel() {
-    return __privateGet(this, _lambdaModel);
+    return this.#lambdaModel;
   }
   AddSubscriptions(subscriptions) {
-    var _a2;
     const subscriptionsToAdd = [];
     subscriptions.map((subscription) => {
       const retVal = this.subscriptions.find((v) => v.subscriptionKey.id.localeCompare(subscription.subscriptionKey.id) === 0);
       if (retVal) {
-        __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.magenta(`AddSubscription(): Subscription: [${retVal.subscriptionKey.id}] already exists - ignoring.`));
+        this.#LogDebugMessage(chalk.magenta(`AddSubscription(): Subscription: [${retVal.subscriptionKey.id}] already exists - ignoring.`));
       } else {
         subscriptionsToAdd.push(subscription);
       }
     });
     if (subscriptionsToAdd.length > 0) {
       subscriptionsToAdd.map((s) => this.subscriptions.push(s));
-      (_a2 = __privateGet(this, _observabilitySocketIOSubscriber)) == null ? void 0 : _a2.Subscribe(subscriptionsToAdd);
+      this.#observabilitySocketIOSubscriber?.Subscribe(subscriptionsToAdd);
     } else {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.magenta(`AddSubscription(): No valid subscriptions to subscribe.`));
+      this.#LogDebugMessage(chalk.magenta(`AddSubscription(): No valid subscriptions to subscribe.`));
     }
   }
   RemoveSubscriptionsByKey(keyToFind) {
-    var _a2;
     const newSubscriptions = [];
     for (let i = 0; i < this.subscriptions.length; i++) {
-      if (((_a2 = this.subscriptions[i].subscriptionKey.key) == null ? void 0 : _a2.localeCompare(keyToFind)) === 0) {
-        if (__privateGet(this, _observabilitySocketIOSubscriber)) {
-          __privateGet(this, _observabilitySocketIOSubscriber).UnSubscribeOne(this.subscriptions[i]);
+      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
+        if (this.#observabilitySocketIOSubscriber) {
+          this.#observabilitySocketIOSubscriber.UnSubscribeOne(this.subscriptions[i]);
         }
       } else {
         newSubscriptions.push(this.subscriptions[i]);
       }
     }
-    __privateSet(this, _subscriptions, newSubscriptions);
+    this.#subscriptions = newSubscriptions;
   }
   FindSubscriptionByKey(keyToFind) {
-    var _a2;
     for (let i = 0; i < this.subscriptions.length; i++) {
-      if (((_a2 = this.subscriptions[i].subscriptionKey.key) == null ? void 0 : _a2.localeCompare(keyToFind)) === 0) {
+      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
         return this.subscriptions[i];
       }
     }
     return void 0;
   }
   FindSubscriptionByKeyAndSubKey(keyToFind, subKeyToFind) {
-    var _a2, _b;
     for (let i = 0; i < this.subscriptions.length; i++) {
-      if (((_a2 = this.subscriptions[i].subscriptionKey.key) == null ? void 0 : _a2.localeCompare(keyToFind)) === 0) {
-        if (((_b = this.subscriptions[i].subscriptionKey.subkey) == null ? void 0 : _b.localeCompare(subKeyToFind)) === 0) {
+      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
+        if (this.subscriptions[i].subscriptionKey.subkey?.localeCompare(subKeyToFind) === 0) {
           return this.subscriptions[i];
         }
       }
@@ -6075,13 +5913,13 @@ class ObservabilitySubscriptionManager {
     return void 0;
   }
   Start() {
-    if (__privateGet(this, _observabilitySocketIOSubscriber)) {
-      __privateGet(this, _observabilitySocketIOSubscriber).Subscribe(this.subscriptions);
+    if (this.#observabilitySocketIOSubscriber) {
+      this.#observabilitySocketIOSubscriber.Subscribe(this.subscriptions);
     }
   }
   Stop() {
-    if (__privateGet(this, _observabilitySocketIOSubscriber)) {
-      __privateGet(this, _observabilitySocketIOSubscriber).UnSubscribe(this.subscriptions);
+    if (this.#observabilitySocketIOSubscriber) {
+      this.#observabilitySocketIOSubscriber.UnSubscribe(this.subscriptions);
     }
   }
   TransformSubscriptionPayloadCallback(subscriptionPayload, subscribeToKafka) {
@@ -6131,26 +5969,26 @@ class ObservabilitySubscriptionManager {
   //  /
   CreateModelAllServicesCombined(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _serviceModel, {});
+      this.#serviceModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllServicesCombined.toString()) === 0) {
-        __privateGet(this, _serviceModel)["STS-Service"] = ObservabilityModelUtils.GetModelForService("STS-Service", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
-        if (__privateGet(this, _serviceModel)["STS-Service"] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllServicesCombined():Error: GetModelForService() returned null`));
+        this.#serviceModel["STS-Service"] = ObservabilityModelUtils.GetModelForService("STS-Service", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+        if (this.#serviceModel["STS-Service"] === null) {
+          this.#LogDebugMessage(chalk.red(`CreateModelAllServicesCombined():Error: GetModelForService() returned null`));
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, error);
+      this.#LogErrorMessage(error);
       return;
     }
   }
   //  /serviceId
   CreateModelServices(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _serviceModel, {});
+      this.#serviceModel = {};
       for (const [serviceId, serviceTelemetry] of Object.entries(subscriptionPayload.data)) {
-        __privateGet(this, _serviceModel)[serviceId] = ObservabilityModelUtils.GetModelForService(serviceId, serviceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-        if (__privateGet(this, _serviceModel)[serviceId] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServices():Error: GetModelForService() returned null`));
+        this.#serviceModel[serviceId] = ObservabilityModelUtils.GetModelForService(serviceId, serviceTelemetry, subscribeToKafka, this.#options.logger);
+        if (this.#serviceModel[serviceId] === null) {
+          this.#LogDebugMessage(chalk.red(`CreateModelServices():Error: GetModelForService() returned null`));
         }
       }
     } catch (error) {
@@ -6160,16 +5998,16 @@ class ObservabilitySubscriptionManager {
   //  /serviceId/serviceInstanceId
   CreateModelServiceInstances(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _serviceModel, {});
+      this.#serviceModel = {};
       for (const [serviceId, service] of Object.entries(subscriptionPayload.data)) {
         for (const [serviceInstanceId, serviceInstanceTelemetry] of Object.entries(service)) {
           const kafkaTopic = `${KAFKA_PREFIX}_${serviceInstanceId}`.replace(/@/g, "_").replace(/\|/g, "_");
           if (serviceInstanceTelemetry.cpu && serviceInstanceTelemetry.cpu > 0) {
-            __privateGet(this, _serviceModel)[serviceInstanceId] = ObservabilityModelUtils.GetModelForService(serviceInstanceId, serviceInstanceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-            if (__privateGet(this, _serviceModel)[serviceInstanceId] !== null) {
-              __privateGet(this, _serviceModel)[serviceInstanceId].options = { serviceId };
+            this.#serviceModel[serviceInstanceId] = ObservabilityModelUtils.GetModelForService(serviceInstanceId, serviceInstanceTelemetry, subscribeToKafka, this.#options.logger);
+            if (this.#serviceModel[serviceInstanceId] !== null) {
+              this.#serviceModel[serviceInstanceId].options = { serviceId };
               if (subscribeToKafka) {
-                __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _serviceModel)[serviceInstanceId]);
+                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#serviceModel[serviceInstanceId]);
                 if (!this.FindSubscriptionByKey(kafkaTopic)) {
                   this.AddSubscriptions([{
                     subscriptionKey: {
@@ -6178,13 +6016,13 @@ class ObservabilitySubscriptionManager {
                       key: kafkaTopic
                     },
                     cb: (payload) => {
-                      __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                      this.#kafkaHelper.ProcessKafkaData(payload);
                     }
                   }]);
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServiceInstances():Error: GetModelForService() returned null`));
+              this.#LogDebugMessage(chalk.red(`CreateModelServiceInstances():Error: GetModelForService() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6202,17 +6040,17 @@ class ObservabilitySubscriptionManager {
   //  serviceId/serviceInstanceId/serviceInstanceProcessId
   CreateModelServiceInstance(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _serviceModel, {});
+      this.#serviceModel = {};
       for (const [serviceId, service] of Object.entries(subscriptionPayload.data)) {
         for (const [serviceInstanceId, serviceInstance] of Object.entries(service)) {
           for (const [serviceInstanceProcessId, serviceInstanceProcessTelemetry] of Object.entries(serviceInstance)) {
             const kafkaTopic = `${KAFKA_PREFIX}_${serviceInstanceId}_${serviceInstanceProcessId}`.replace(/@/g, "_").replace(/\|/g, "_");
             if (serviceInstanceProcessTelemetry.cpu && serviceInstanceProcessTelemetry.cpu > 0) {
-              __privateGet(this, _serviceModel)[serviceInstanceProcessId] = ObservabilityModelUtils.GetModelForService(serviceInstanceProcessId, serviceInstanceProcessTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-              if (__privateGet(this, _serviceModel)[serviceInstanceProcessId] !== null) {
-                __privateGet(this, _serviceModel)[serviceInstanceProcessId].options = { serviceId, serviceInstanceId };
+              this.#serviceModel[serviceInstanceProcessId] = ObservabilityModelUtils.GetModelForService(serviceInstanceProcessId, serviceInstanceProcessTelemetry, subscribeToKafka, this.#options.logger);
+              if (this.#serviceModel[serviceInstanceProcessId] !== null) {
+                this.#serviceModel[serviceInstanceProcessId].options = { serviceId, serviceInstanceId };
                 if (subscribeToKafka) {
-                  __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _serviceModel)[serviceInstanceProcessId]);
+                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#serviceModel[serviceInstanceProcessId]);
                   if (!this.FindSubscriptionByKey(kafkaTopic)) {
                     this.AddSubscriptions([{
                       subscriptionKey: {
@@ -6221,13 +6059,13 @@ class ObservabilitySubscriptionManager {
                         key: kafkaTopic
                       },
                       cb: (payload) => {
-                        __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                        this.#kafkaHelper.ProcessKafkaData(payload);
                       }
                     }]);
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelServiceInstance():Error: GetModelForService() returned null`));
+                this.#LogDebugMessage(chalk.red(`CreateModelServiceInstance():Error: GetModelForService() returned null`));
               }
             } else {
               if (subscribeToKafka) {
@@ -6247,31 +6085,31 @@ class ObservabilitySubscriptionManager {
   // /
   CreateModelAllAgentsCombined(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _agentModel, {});
+      this.#agentModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllAgentsCombined.toString()) === 0) {
         if (Object.keys(subscriptionPayload.data).length !== 0) {
-          __privateGet(this, _agentModel)["STS-Agent"] = ObservabilityModelUtils.GetModelForAgent("STS-Agent", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
-          if (__privateGet(this, _agentModel)["STS-Agent"] === null) {
-            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllAgentsCombined():Error: GetModelForAgent() returned null`));
+          this.#agentModel["STS-Agent"] = ObservabilityModelUtils.GetModelForAgent("STS-Agent", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+          if (this.#agentModel["STS-Agent"] === null) {
+            this.#LogDebugMessage(chalk.red(`CreateModelAllAgentsCombined():Error: GetModelForAgent() returned null`));
           }
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, error);
+      this.#LogErrorMessage(error);
       return;
     }
   }
   // /agentId
   CreateModelAgents(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _agentModel, {});
+      this.#agentModel = {};
       for (const [agentId, agentInstanceTelemetry] of Object.entries(subscriptionPayload.data)) {
         const kafkaTopic = `${KAFKA_PREFIX}_${agentId}`.replace(/@/g, "_").replace(/\|/g, "_");
         if (agentInstanceTelemetry.timer) {
-          __privateGet(this, _agentModel)[agentId] = ObservabilityModelUtils.GetModelForAgent(agentId, agentInstanceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-          if (__privateGet(this, _agentModel)[agentId] !== null) {
+          this.#agentModel[agentId] = ObservabilityModelUtils.GetModelForAgent(agentId, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
+          if (this.#agentModel[agentId] !== null) {
             if (subscribeToKafka) {
-              __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _agentModel)[agentId]);
+              this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[agentId]);
               if (!this.FindSubscriptionByKey(kafkaTopic)) {
                 this.AddSubscriptions([{
                   subscriptionKey: {
@@ -6280,13 +6118,13 @@ class ObservabilitySubscriptionManager {
                     key: kafkaTopic
                   },
                   cb: (payload) => {
-                    __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                    this.#kafkaHelper.ProcessKafkaData(payload);
                   }
                 }]);
               }
             }
           } else {
-            __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgents():Error: GetModelForAgent() returned null`));
+            this.#LogDebugMessage(chalk.red(`CreateModelAgents():Error: GetModelForAgent() returned null`));
           }
         } else {
           if (subscribeToKafka) {
@@ -6297,25 +6135,25 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgent:CreateModel(): Error: [${error}]`));
+      this.#LogErrorMessage(chalk.red(`UIControllerAgent:CreateModel(): Error: [${error}]`));
     }
   }
   // /agentId/agentWorkerId
   CreateModelAgentWorkers(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _agentModel, {});
+      this.#agentModel = {};
       for (const [agentId, agentWorker] of Object.entries(subscriptionPayload.data)) {
         for (const [agentWorkerId, agentInstanceTelemetry] of Object.entries(agentWorker)) {
           const kafkaTopic = `${KAFKA_PREFIX}_${agentId}_${agentWorkerId}`.replace(/@/g, "_").replace(/\|/g, "_");
           if (agentInstanceTelemetry.timer) {
             const threadKey = `${agentWorkerId}`;
-            __privateGet(this, _agentModel)[threadKey] = ObservabilityModelUtils.GetModelForAgent(threadKey, agentInstanceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-            if (__privateGet(this, _agentModel)[threadKey] !== null) {
-              const coreCount = __privateGet(this, _agentModel)[threadKey].instruments[Gauge.CORE_COUNT_GAUGE].val;
-              __privateGet(this, _agentModel)[threadKey].canNavigate = coreCount > 0;
-              __privateGet(this, _agentModel)[threadKey].options = { agentId };
+            this.#agentModel[threadKey] = ObservabilityModelUtils.GetModelForAgent(threadKey, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
+            if (this.#agentModel[threadKey] !== null) {
+              const coreCount = this.#agentModel[threadKey].instruments[Gauge.CORE_COUNT_GAUGE].val;
+              this.#agentModel[threadKey].canNavigate = coreCount > 0;
+              this.#agentModel[threadKey].options = { agentId };
               if (subscribeToKafka) {
-                __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _agentModel)[threadKey]);
+                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[threadKey]);
                 if (!this.FindSubscriptionByKey(kafkaTopic)) {
                   this.AddSubscriptions([{
                     subscriptionKey: {
@@ -6324,13 +6162,13 @@ class ObservabilitySubscriptionManager {
                       key: kafkaTopic
                     },
                     cb: (payload) => {
-                      __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                      this.#kafkaHelper.ProcessKafkaData(payload);
                     }
                   }]);
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgentWorkers():Error: GetModelForAgent() returned null`));
+              this.#LogDebugMessage(chalk.red(`CreateModelAgentWorkers():Error: GetModelForAgent() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6342,22 +6180,22 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgentThreads:CreateModel(): Error: [${error}]`));
+      this.#LogErrorMessage(chalk.red(`UIControllerAgentThreads:CreateModel(): Error: [${error}]`));
     }
   }
   // /agentId/agentWorkerId/asyncRunnerId
   CreateModelAgentWorker(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _agentModel, {});
+      this.#agentModel = {};
       for (const [agentId, agentWorker] of Object.entries(subscriptionPayload.data)) {
         for (const [agentWorkerId, asyncRunnerData] of Object.entries(agentWorker)) {
           for (const [asyncRunnerId, agentInstanceTelemetry] of Object.entries(asyncRunnerData)) {
             const kafkaTopic = `${KAFKA_PREFIX}_${agentId}_${agentWorkerId}_${asyncRunnerId}`.replace(/@/g, "_").replace(/\|/g, "_");
             if (agentInstanceTelemetry.timer) {
-              __privateGet(this, _agentModel)[asyncRunnerId] = ObservabilityModelUtils.GetModelForAgent(asyncRunnerId, agentInstanceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-              if (__privateGet(this, _agentModel)[asyncRunnerId] !== null) {
+              this.#agentModel[asyncRunnerId] = ObservabilityModelUtils.GetModelForAgent(asyncRunnerId, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
+              if (this.#agentModel[asyncRunnerId] !== null) {
                 if (subscribeToKafka) {
-                  __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _agentModel)[asyncRunnerId]);
+                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[asyncRunnerId]);
                   if (!this.FindSubscriptionByKey(kafkaTopic)) {
                     this.AddSubscriptions([{
                       subscriptionKey: {
@@ -6366,13 +6204,13 @@ class ObservabilitySubscriptionManager {
                         key: kafkaTopic
                       },
                       cb: (payload) => {
-                        __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                        this.#kafkaHelper.ProcessKafkaData(payload);
                       }
                     }]);
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAgentWorker():Error: GetModelForAgent() returned null`));
+                this.#LogDebugMessage(chalk.red(`CreateModelAgentWorker():Error: GetModelForAgent() returned null`));
               }
             } else {
               if (subscribeToKafka) {
@@ -6385,33 +6223,33 @@ class ObservabilitySubscriptionManager {
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, chalk.red(`UIControllerAgentThread:CreateModel(): Error: [${error}]`));
+      this.#LogErrorMessage(chalk.red(`UIControllerAgentThread:CreateModel(): Error: [${error}]`));
     }
   }
   // --- [ Lambdas ] ------------------------------------------------------------------------------------------------------------------------------------------------
   //  /
   CreateModelAllLambdasCombined(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _lambdaModel, {});
+      this.#lambdaModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllLambdasCombined.toString()) === 0) {
-        __privateGet(this, _lambdaModel)["STS-Lambda"] = ObservabilityModelUtils.GetModelForLambda("STS-Lambda", subscriptionPayload.data, subscribeToKafka, __privateGet(this, _options5).logger);
-        if (__privateGet(this, _lambdaModel)["STS-Lambda"] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelAllLambdasCombined():Error: GetModelForLambda() returned null`));
+        this.#lambdaModel["STS-Lambda"] = ObservabilityModelUtils.GetModelForLambda("STS-Lambda", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+        if (this.#lambdaModel["STS-Lambda"] === null) {
+          this.#LogDebugMessage(chalk.red(`CreateModelAllLambdasCombined():Error: GetModelForLambda() returned null`));
         }
       }
     } catch (error) {
-      __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogErrorMessage_fn3).call(this, error);
+      this.#LogErrorMessage(error);
       return;
     }
   }
   //  /technologyId
   CreateModelLambdaTechnologies(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _lambdaModel, {});
+      this.#lambdaModel = {};
       for (const [technologyId, technologyTelemetry] of Object.entries(subscriptionPayload.data)) {
-        __privateGet(this, _lambdaModel)[technologyId] = ObservabilityModelUtils.GetModelForLambda(technologyId, technologyTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-        if (__privateGet(this, _lambdaModel)[technologyId] === null) {
-          __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaTechnologies():Error: GetModelForLambda() returned null`));
+        this.#lambdaModel[technologyId] = ObservabilityModelUtils.GetModelForLambda(technologyId, technologyTelemetry, subscribeToKafka, this.#options.logger);
+        if (this.#lambdaModel[technologyId] === null) {
+          this.#LogDebugMessage(chalk.red(`CreateModelLambdaTechnologies():Error: GetModelForLambda() returned null`));
         }
       }
     } catch (error) {
@@ -6421,16 +6259,16 @@ class ObservabilitySubscriptionManager {
   //  /technologyId/subTechnologyId
   CreateModelLambdaSubTechnologies(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _lambdaModel, {});
+      this.#lambdaModel = {};
       for (const [technologyId, technologyTelemetry] of Object.entries(subscriptionPayload.data)) {
         for (const [subTechnologyId, subTechnologyTelemetry] of Object.entries(technologyTelemetry)) {
           const kafkaTopic = `${KAFKA_PREFIX}_${subTechnologyId}`.replace(/@/g, "_").replace(/\|/g, "_");
           if (subTechnologyTelemetry.cpu && subTechnologyTelemetry.cpu > 0) {
-            __privateGet(this, _lambdaModel)[subTechnologyId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyId, subTechnologyTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-            if (__privateGet(this, _lambdaModel)[subTechnologyId] !== null) {
-              __privateGet(this, _lambdaModel)[subTechnologyId].options = { technologyId };
+            this.#lambdaModel[subTechnologyId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyId, subTechnologyTelemetry, subscribeToKafka, this.#options.logger);
+            if (this.#lambdaModel[subTechnologyId] !== null) {
+              this.#lambdaModel[subTechnologyId].options = { technologyId };
               if (subscribeToKafka) {
-                __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _lambdaModel)[subTechnologyId]);
+                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#lambdaModel[subTechnologyId]);
                 if (!this.FindSubscriptionByKey(kafkaTopic)) {
                   this.AddSubscriptions([{
                     subscriptionKey: {
@@ -6439,13 +6277,13 @@ class ObservabilitySubscriptionManager {
                       key: kafkaTopic
                     },
                     cb: (payload) => {
-                      __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                      this.#kafkaHelper.ProcessKafkaData(payload);
                     }
                   }]);
                 }
               }
             } else {
-              __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaSubTechnologies():Error: GetModelForLambda() returned null`));
+              this.#LogDebugMessage(chalk.red(`CreateModelLambdaSubTechnologies():Error: GetModelForLambda() returned null`));
             }
           } else {
             if (subscribeToKafka) {
@@ -6463,17 +6301,17 @@ class ObservabilitySubscriptionManager {
   //   /technologyId/subTechnologyId/subTechnologyInstanceId
   CreateModelLambdaSubTechnologiesInstance(subscriptionPayload, subscribeToKafka) {
     try {
-      __privateSet(this, _lambdaModel, {});
+      this.#lambdaModel = {};
       for (const [technologyId, technologyTelemetry] of Object.entries(subscriptionPayload.data)) {
         for (const [subTechnologyId, subTechnologyTelemetry] of Object.entries(technologyTelemetry)) {
           for (const [subTechnologyInstanceId, subTechnologyInstanceTelemetry] of Object.entries(subTechnologyTelemetry)) {
             const kafkaTopic = `${KAFKA_PREFIX}_${subTechnologyId}_${subTechnologyInstanceId}`.replace(/@/g, "_").replace(/\|/g, "_");
             if (subTechnologyInstanceTelemetry.cpu && subTechnologyInstanceTelemetry.cpu > 0) {
-              __privateGet(this, _lambdaModel)[subTechnologyInstanceId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyInstanceId, subTechnologyInstanceTelemetry, subscribeToKafka, __privateGet(this, _options5).logger);
-              if (__privateGet(this, _lambdaModel)[subTechnologyInstanceId] !== null) {
-                __privateGet(this, _lambdaModel)[subTechnologyInstanceId].options = { technologyId, subTechnologyId };
+              this.#lambdaModel[subTechnologyInstanceId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyInstanceId, subTechnologyInstanceTelemetry, subscribeToKafka, this.#options.logger);
+              if (this.#lambdaModel[subTechnologyInstanceId] !== null) {
+                this.#lambdaModel[subTechnologyInstanceId].options = { technologyId, subTechnologyId };
                 if (subscribeToKafka) {
-                  __privateGet(this, _kafkaHelper).GetKafkaLogData(kafkaTopic, __privateGet(this, _lambdaModel)[subTechnologyInstanceId]);
+                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#lambdaModel[subTechnologyInstanceId]);
                   if (!this.FindSubscriptionByKey(kafkaTopic)) {
                     this.AddSubscriptions([{
                       subscriptionKey: {
@@ -6482,13 +6320,13 @@ class ObservabilitySubscriptionManager {
                         key: kafkaTopic
                       },
                       cb: (payload) => {
-                        __privateGet(this, _kafkaHelper).ProcessKafkaData(payload);
+                        this.#kafkaHelper.ProcessKafkaData(payload);
                       }
                     }]);
                   }
                 }
               } else {
-                __privateMethod(this, _ObservabilitySubscriptionManager_instances, LogDebugMessage_fn4).call(this, chalk.red(`CreateModelLambdaSubTechnologiesInstance():Error: GetModelForLambda() returned null`));
+                this.#LogDebugMessage(chalk.red(`CreateModelLambdaSubTechnologiesInstance():Error: GetModelForLambda() returned null`));
               }
             } else {
               if (subscribeToKafka) {
@@ -6505,20 +6343,6 @@ class ObservabilitySubscriptionManager {
     }
   }
 }
-_observabilitySocketIOSubscriber = new WeakMap();
-_subscriptions = new WeakMap();
-_kafkaHelper = new WeakMap();
-_serviceModel = new WeakMap();
-_agentModel = new WeakMap();
-_lambdaModel = new WeakMap();
-_options5 = new WeakMap();
-_ObservabilitySubscriptionManager_instances = new WeakSet();
-LogDebugMessage_fn4 = function(message) {
-  __privateGet(this, _options5).logger.debug(message);
-};
-LogErrorMessage_fn3 = function(message) {
-  __privateGet(this, _options5).logger.error(message);
-};
 export {
   CompareSTSInstrumentControllerPluginKey,
   CreateInstrument,