@nsshunt/stsobservability 1.0.131 → 1.0.132

package/dist/{stsobservability.mjs → index.mjs}

@@ -5299,7 +5299,7 @@ class ObservabilityModelUtils {
       }
     });
   }
-  static GetModelForService(id, data, subscribeToKafka, logger) {
+  static GetModelForService(id, data, logger) {
     try {
       const parseLog = [];
       const model = {
@@ -5307,9 +5307,7 @@ class ObservabilityModelUtils {
         instruments: {}
       };
       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));
       }
@@ -5318,7 +5316,7 @@ class ObservabilityModelUtils {
       return null;
     }
   }
-  static GetModelForLambda(id, data, subscribeToKafka, logger) {
+  static GetModelForLambda(id, data, logger) {
     try {
       const parseLog = [];
       const model = {
@@ -5326,9 +5324,7 @@ class ObservabilityModelUtils {
         instruments: {}
       };
       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));
       }
@@ -5337,7 +5333,7 @@ class ObservabilityModelUtils {
       return null;
     }
   }
-  static GetModelForAgent(id, data, subscribeToKafka, logger) {
+  static GetModelForAgent(id, data, logger) {
     try {
       if (Object.keys(data).length === 0) {
         return null;
@@ -5348,9 +5344,7 @@ class ObservabilityModelUtils {
         instruments: {}
       };
       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));
       }
@@ -5360,36 +5354,6 @@ class ObservabilityModelUtils {
     }
   }
 }
-class KafkaHelper {
-  #kafkaLog = {};
-  #maxLogLength;
-  constructor(options) {
-    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: []
-        };
-      }
-      this.#kafkaLog[kafkaTopic].kafkaLog.push(value);
-      while (this.#kafkaLog[kafkaTopic].kafkaLog.length > this.#maxLogLength) {
-        this.#kafkaLog[kafkaTopic].kafkaLog.shift();
-      }
-    }
-  };
-}
 class ObservabilityRESTAPISubscriber {
   #socketSubscribeKeepAlive = {};
   #options;
@@ -5646,42 +5610,6 @@ class ObservabilitySocketIOSubscriber {
     });
   }
 }
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-  if (!getRandomValues) {
-    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
-      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    }
-    getRandomValues = crypto.getRandomValues.bind(crypto);
-  }
-  return getRandomValues(rnds8);
-}
-const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = { randomUUID };
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  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 runStates = /* @__PURE__ */ ((runStates2) => {
   runStates2["idle"] = "idle";
   runStates2["started"] = "started";
@@ -5689,43 +5617,18 @@ var runStates = /* @__PURE__ */ ((runStates2) => {
   return runStates2;
 })(runStates || {});
 class ObservabilitySubscriptionManager {
-  #observabilitySocketIOSubscriber = null;
-  #subscriptions = [];
-  #kafkaHelper;
   #serviceModel = {};
   #agentModel = {};
   #lambdaModel = {};
   #options;
-  #runState = "idle";
   #LogDebugMessage(message) {
     this.#options.logger.debug(message);
   }
   #LogErrorMessage(message) {
     this.#options.logger.error(message);
   }
-  #LogWarnMessage(message) {
-    this.#options.logger.warn(message);
-  }
   constructor(options) {
     this.#options = options;
-    this.#kafkaHelper = new KafkaHelper({
-      maxLogLength: this.#options.maxLogLength
-    });
-  }
-  get runState() {
-    return this.#runState;
-  }
-  get observabilitySocketIOSubscriber() {
-    return this.#observabilitySocketIOSubscriber;
-  }
-  set observabilitySocketIOSubscriber(observabilitySocketIOSubscriber) {
-    this.#observabilitySocketIOSubscriber = observabilitySocketIOSubscriber;
-  }
-  get subscriptions() {
-    return this.#subscriptions;
-  }
-  set subscriptions(subscriptions) {
-    this.#subscriptions = subscriptions;
   }
   get serviceModel() {
     return this.#serviceModel;
@@ -5736,131 +5639,56 @@ class ObservabilitySubscriptionManager {
   get lambdaModel() {
     return this.#lambdaModel;
   }
-  AddSubscriptions(subscriptions) {
-    const subscriptionsToAdd = [];
-    subscriptions.map((subscription) => {
-      const retVal = this.subscriptions.find((v) => v.subscriptionKey.id.localeCompare(subscription.subscriptionKey.id) === 0);
-      if (retVal) {
-        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));
-      this.#observabilitySocketIOSubscriber?.Subscribe(subscriptionsToAdd);
-    } else {
-      this.#LogDebugMessage(chalk.magenta(`AddSubscription(): No valid subscriptions to subscribe.`));
-    }
-  }
-  RemoveSubscriptionsByKey(keyToFind) {
-    const newSubscriptions = [];
-    for (let i = 0; i < this.subscriptions.length; i++) {
-      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
-        if (this.#observabilitySocketIOSubscriber) {
-          this.#observabilitySocketIOSubscriber.UnSubscribe([this.subscriptions[i]]);
-        }
-      } else {
-        newSubscriptions.push(this.subscriptions[i]);
-      }
-    }
-    this.#subscriptions = newSubscriptions;
-  }
-  FindSubscriptionByKey(keyToFind) {
-    for (let i = 0; i < this.subscriptions.length; i++) {
-      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
-        return this.subscriptions[i];
-      }
-    }
-    return void 0;
-  }
-  FindSubscriptionByKeyAndSubKey(keyToFind, subKeyToFind) {
-    for (let i = 0; i < this.subscriptions.length; i++) {
-      if (this.subscriptions[i].subscriptionKey.key?.localeCompare(keyToFind) === 0) {
-        if (this.subscriptions[i].subscriptionKey.subkey?.localeCompare(subKeyToFind) === 0) {
-          return this.subscriptions[i];
-        }
-      }
-    }
-    return void 0;
-  }
-  Start() {
-    const initialState = this.#runState;
-    if (this.#runState === "started") {
-      this.#LogWarnMessage(`ObservabilitySubscriptionManager:Start(): Warning: [run state already started]`);
-    }
-    if (this.#observabilitySocketIOSubscriber) {
-      this.#LogDebugMessage(`ObservabilitySubscriptionManager:Start(): observabilitySocketIOSubscriber.Subscribe(${JSON.stringify(this.subscriptions)})`);
-      this.#observabilitySocketIOSubscriber.Subscribe(this.subscriptions);
-    }
-    this.#runState = "started";
-    this.#LogDebugMessage(`ObservabilitySubscriptionManager:Start(): runState: [${this.#runState}] (was: [${initialState}])`);
-  }
-  Stop() {
-    const initialState = this.#runState;
-    if (this.#runState === "stopped") {
-      this.#LogWarnMessage(`ObservabilitySubscriptionManager:Stop(): Warning: [run state already stopped]`);
-    }
-    if (this.#runState === "idle") {
-      this.#LogWarnMessage(`ObservabilitySubscriptionManager:Stop(): Warning: [run state currently idle (not started)]`);
-    }
-    if (this.#observabilitySocketIOSubscriber) {
-      this.#LogDebugMessage(`ObservabilitySubscriptionManager:Start(): observabilitySocketIOSubscriber.UnSubscribe(${JSON.stringify(this.subscriptions)})`);
-      this.#observabilitySocketIOSubscriber.UnSubscribe(this.subscriptions);
-    }
-    this.#runState = "stopped";
-    this.#LogDebugMessage(`ObservabilitySubscriptionManager:Start(): runState: [${this.#runState}] (was: [${initialState}])`);
-  }
-  TransformSubscriptionPayloadCallback(subscriptionPayload, subscribeToKafka) {
+  TransformSubscriptionPayloadCallback(subscriptionPayload) {
     switch (subscriptionPayload.subscriptionKey.topic) {
       // Services -----------------------------------------------------------------------------
       case SubscriptionTopic.AllServicesCombined:
-        this.CreateModelAllServicesCombined(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAllServicesCombined(subscriptionPayload);
         break;
       case SubscriptionTopic.Services:
-        this.CreateModelServices(subscriptionPayload, subscribeToKafka);
+        this.CreateModelServices(subscriptionPayload);
         break;
       case SubscriptionTopic.ServiceInstances:
-        this.CreateModelServiceInstances(subscriptionPayload, subscribeToKafka);
+        this.CreateModelServiceInstances(subscriptionPayload);
         break;
       case SubscriptionTopic.ServiceInstance:
-        this.CreateModelServiceInstance(subscriptionPayload, subscribeToKafka);
+        this.CreateModelServiceInstance(subscriptionPayload);
         break;
       // Lambda -----------------------------------------------------------------------------
       case SubscriptionTopic.AllLambdasCombined:
-        this.CreateModelAllLambdasCombined(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAllLambdasCombined(subscriptionPayload);
         break;
       case SubscriptionTopic.LambdaTechnologies:
-        this.CreateModelLambdaTechnologies(subscriptionPayload, subscribeToKafka);
+        this.CreateModelLambdaTechnologies(subscriptionPayload);
         break;
       case SubscriptionTopic.LambdaSubTechnologies:
-        this.CreateModelLambdaSubTechnologies(subscriptionPayload, subscribeToKafka);
+        this.CreateModelLambdaSubTechnologies(subscriptionPayload);
         break;
       case SubscriptionTopic.LambdaSubTechnologiesInstance:
-        this.CreateModelLambdaSubTechnologiesInstance(subscriptionPayload, subscribeToKafka);
+        this.CreateModelLambdaSubTechnologiesInstance(subscriptionPayload);
         break;
       // Agents -----------------------------------------------------------------------------
       case SubscriptionTopic.AllAgentsCombined:
-        this.CreateModelAllAgentsCombined(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAllAgentsCombined(subscriptionPayload);
         break;
       case SubscriptionTopic.Agents:
-        this.CreateModelAgents(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAgents(subscriptionPayload);
         break;
       case SubscriptionTopic.AgentWorkers:
-        this.CreateModelAgentWorkers(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAgentWorkers(subscriptionPayload);
         break;
       case SubscriptionTopic.AgentWorker:
-        this.CreateModelAgentWorker(subscriptionPayload, subscribeToKafka);
+        this.CreateModelAgentWorker(subscriptionPayload);
         break;
     }
   }
   // --- [ Services ] ------------------------------------------------------------------------------------------------------------------------------------------------
   //  /
-  CreateModelAllServicesCombined(subscriptionPayload, subscribeToKafka) {
+  CreateModelAllServicesCombined(subscriptionPayload) {
     try {
       this.#serviceModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllServicesCombined.toString()) === 0) {
-        this.#serviceModel["STS-Service"] = ObservabilityModelUtils.GetModelForService("STS-Service", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+        this.#serviceModel["STS-Service"] = ObservabilityModelUtils.GetModelForService("STS-Service", subscriptionPayload.data, this.#options.logger);
         if (this.#serviceModel["STS-Service"] === null) {
           this.#LogDebugMessage(chalk.red(`CreateModelAllServicesCombined():Error: GetModelForService() returned null`));
         }
@@ -5871,11 +5699,11 @@ class ObservabilitySubscriptionManager {
     }
   }
   //  /serviceId
-  CreateModelServices(subscriptionPayload, subscribeToKafka) {
+  CreateModelServices(subscriptionPayload) {
     try {
       this.#serviceModel = {};
       for (const [serviceId, serviceTelemetry] of Object.entries(subscriptionPayload.data)) {
-        this.#serviceModel[serviceId] = ObservabilityModelUtils.GetModelForService(serviceId, serviceTelemetry, subscribeToKafka, this.#options.logger);
+        this.#serviceModel[serviceId] = ObservabilityModelUtils.GetModelForService(serviceId, serviceTelemetry, this.#options.logger);
         if (this.#serviceModel[serviceId] === null) {
           this.#LogDebugMessage(chalk.red(`CreateModelServices():Error: GetModelForService() returned null`));
         }
@@ -5885,40 +5713,18 @@ class ObservabilitySubscriptionManager {
     }
   }
   //  /serviceId/serviceInstanceId
-  CreateModelServiceInstances(subscriptionPayload, subscribeToKafka) {
+  CreateModelServiceInstances(subscriptionPayload) {
     try {
       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) {
-            this.#serviceModel[serviceInstanceId] = ObservabilityModelUtils.GetModelForService(serviceInstanceId, serviceInstanceTelemetry, subscribeToKafka, this.#options.logger);
+            this.#serviceModel[serviceInstanceId] = ObservabilityModelUtils.GetModelForService(serviceInstanceId, serviceInstanceTelemetry, this.#options.logger);
             if (this.#serviceModel[serviceInstanceId] !== null) {
               this.#serviceModel[serviceInstanceId].options = { serviceId };
-              if (subscribeToKafka) {
-                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#serviceModel[serviceInstanceId]);
-                if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.AddSubscriptions([{
-                    subscriptionKey: {
-                      id: v4(),
-                      topic: SubscriptionTopic.LogProcessing,
-                      key: kafkaTopic
-                    },
-                    cb: (payload) => {
-                      this.#kafkaHelper.ProcessKafkaData(payload);
-                    }
-                  }]);
-                }
-              }
             } else {
               this.#LogDebugMessage(chalk.red(`CreateModelServiceInstances():Error: GetModelForService() returned null`));
             }
-          } else {
-            if (subscribeToKafka) {
-              if (this.FindSubscriptionByKey(kafkaTopic)) {
-                this.RemoveSubscriptionsByKey(kafkaTopic);
-              }
-            }
           }
         }
       }
@@ -5927,41 +5733,19 @@ class ObservabilitySubscriptionManager {
     }
   }
   //  serviceId/serviceInstanceId/serviceInstanceProcessId
-  CreateModelServiceInstance(subscriptionPayload, subscribeToKafka) {
+  CreateModelServiceInstance(subscriptionPayload) {
     try {
       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) {
-              this.#serviceModel[serviceInstanceProcessId] = ObservabilityModelUtils.GetModelForService(serviceInstanceProcessId, serviceInstanceProcessTelemetry, subscribeToKafka, this.#options.logger);
+              this.#serviceModel[serviceInstanceProcessId] = ObservabilityModelUtils.GetModelForService(serviceInstanceProcessId, serviceInstanceProcessTelemetry, this.#options.logger);
               if (this.#serviceModel[serviceInstanceProcessId] !== null) {
                 this.#serviceModel[serviceInstanceProcessId].options = { serviceId, serviceInstanceId };
-                if (subscribeToKafka) {
-                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#serviceModel[serviceInstanceProcessId]);
-                  if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                    this.AddSubscriptions([{
-                      subscriptionKey: {
-                        id: v4(),
-                        topic: SubscriptionTopic.LogProcessing,
-                        key: kafkaTopic
-                      },
-                      cb: (payload) => {
-                        this.#kafkaHelper.ProcessKafkaData(payload);
-                      }
-                    }]);
-                  }
-                }
               } else {
                 this.#LogDebugMessage(chalk.red(`CreateModelServiceInstance():Error: GetModelForService() returned null`));
               }
-            } else {
-              if (subscribeToKafka) {
-                if (this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.RemoveSubscriptionsByKey(kafkaTopic);
-                }
-              }
             }
           }
         }
@@ -5972,12 +5756,12 @@ class ObservabilitySubscriptionManager {
   }
   // --- [ Agents ] ------------------------------------------------------------------------------------------------------------------------------------------------
   // /
-  CreateModelAllAgentsCombined(subscriptionPayload, subscribeToKafka) {
+  CreateModelAllAgentsCombined(subscriptionPayload) {
     try {
       this.#agentModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllAgentsCombined.toString()) === 0) {
         if (Object.keys(subscriptionPayload.data).length !== 0) {
-          this.#agentModel["STS-Agent"] = ObservabilityModelUtils.GetModelForAgent("STS-Agent", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+          this.#agentModel["STS-Agent"] = ObservabilityModelUtils.GetModelForAgent("STS-Agent", subscriptionPayload.data, this.#options.logger);
           if (this.#agentModel["STS-Agent"] === null) {
             this.#LogDebugMessage(chalk.red(`CreateModelAllAgentsCombined():Error: GetModelForAgent() returned null`));
           }
@@ -5989,38 +5773,16 @@ class ObservabilitySubscriptionManager {
     }
   }
   // /agentId
-  CreateModelAgents(subscriptionPayload, subscribeToKafka) {
+  CreateModelAgents(subscriptionPayload) {
     try {
       this.#agentModel = {};
       for (const [agentId, agentInstanceTelemetry] of Object.entries(subscriptionPayload.data)) {
-        const kafkaTopic = `${KAFKA_PREFIX}_${agentId}`.replace(/@/g, "_").replace(/\|/g, "_");
         if (agentInstanceTelemetry.timer) {
-          this.#agentModel[agentId] = ObservabilityModelUtils.GetModelForAgent(agentId, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
+          this.#agentModel[agentId] = ObservabilityModelUtils.GetModelForAgent(agentId, agentInstanceTelemetry, this.#options.logger);
           if (this.#agentModel[agentId] !== null) {
-            if (subscribeToKafka) {
-              this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[agentId]);
-              if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                this.AddSubscriptions([{
-                  subscriptionKey: {
-                    id: v4(),
-                    topic: SubscriptionTopic.LogProcessing,
-                    key: kafkaTopic
-                  },
-                  cb: (payload) => {
-                    this.#kafkaHelper.ProcessKafkaData(payload);
-                  }
-                }]);
-              }
-            }
           } else {
             this.#LogDebugMessage(chalk.red(`CreateModelAgents():Error: GetModelForAgent() returned null`));
           }
-        } else {
-          if (subscribeToKafka) {
-            if (this.FindSubscriptionByKey(kafkaTopic)) {
-              this.RemoveSubscriptionsByKey(kafkaTopic);
-            }
-          }
         }
       }
     } catch (error) {
@@ -6028,43 +5790,21 @@ class ObservabilitySubscriptionManager {
     }
   }
   // /agentId/agentWorkerId
-  CreateModelAgentWorkers(subscriptionPayload, subscribeToKafka) {
+  CreateModelAgentWorkers(subscriptionPayload) {
     try {
       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}`;
-            this.#agentModel[threadKey] = ObservabilityModelUtils.GetModelForAgent(threadKey, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
+            this.#agentModel[threadKey] = ObservabilityModelUtils.GetModelForAgent(threadKey, agentInstanceTelemetry, 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) {
-                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[threadKey]);
-                if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.AddSubscriptions([{
-                    subscriptionKey: {
-                      id: v4(),
-                      topic: SubscriptionTopic.LogProcessing,
-                      key: kafkaTopic
-                    },
-                    cb: (payload) => {
-                      this.#kafkaHelper.ProcessKafkaData(payload);
-                    }
-                  }]);
-                }
-              }
             } else {
               this.#LogDebugMessage(chalk.red(`CreateModelAgentWorkers():Error: GetModelForAgent() returned null`));
             }
-          } else {
-            if (subscribeToKafka) {
-              if (this.FindSubscriptionByKey(kafkaTopic)) {
-                this.RemoveSubscriptionsByKey(kafkaTopic);
-              }
-            }
           }
         }
       }
@@ -6073,40 +5813,14 @@ class ObservabilitySubscriptionManager {
     }
   }
   // /agentId/agentWorkerId/asyncRunnerId
-  CreateModelAgentWorker(subscriptionPayload, subscribeToKafka) {
+  CreateModelAgentWorker(subscriptionPayload) {
     try {
       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) {
-              this.#agentModel[asyncRunnerId] = ObservabilityModelUtils.GetModelForAgent(asyncRunnerId, agentInstanceTelemetry, subscribeToKafka, this.#options.logger);
-              if (this.#agentModel[asyncRunnerId] !== null) {
-                if (subscribeToKafka) {
-                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#agentModel[asyncRunnerId]);
-                  if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                    this.AddSubscriptions([{
-                      subscriptionKey: {
-                        id: v4(),
-                        topic: SubscriptionTopic.LogProcessing,
-                        key: kafkaTopic
-                      },
-                      cb: (payload) => {
-                        this.#kafkaHelper.ProcessKafkaData(payload);
-                      }
-                    }]);
-                  }
-                }
-              } else {
-                this.#LogDebugMessage(chalk.red(`CreateModelAgentWorker():Error: GetModelForAgent() returned null`));
-              }
-            } else {
-              if (subscribeToKafka) {
-                if (this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.RemoveSubscriptionsByKey(kafkaTopic);
-                }
-              }
+              this.#agentModel[asyncRunnerId] = ObservabilityModelUtils.GetModelForAgent(asyncRunnerId, agentInstanceTelemetry, this.#options.logger);
             }
           }
         }
@@ -6117,11 +5831,11 @@ class ObservabilitySubscriptionManager {
   }
   // --- [ Lambdas ] ------------------------------------------------------------------------------------------------------------------------------------------------
   //  /
-  CreateModelAllLambdasCombined(subscriptionPayload, subscribeToKafka) {
+  CreateModelAllLambdasCombined(subscriptionPayload) {
     try {
       this.#lambdaModel = {};
       if (subscriptionPayload.subscriptionKey.topic.localeCompare(SubscriptionTopic.AllLambdasCombined.toString()) === 0) {
-        this.#lambdaModel["STS-Lambda"] = ObservabilityModelUtils.GetModelForLambda("STS-Lambda", subscriptionPayload.data, subscribeToKafka, this.#options.logger);
+        this.#lambdaModel["STS-Lambda"] = ObservabilityModelUtils.GetModelForLambda("STS-Lambda", subscriptionPayload.data, this.#options.logger);
         if (this.#lambdaModel["STS-Lambda"] === null) {
           this.#LogDebugMessage(chalk.red(`CreateModelAllLambdasCombined():Error: GetModelForLambda() returned null`));
         }
@@ -6132,11 +5846,11 @@ class ObservabilitySubscriptionManager {
     }
   }
   //  /technologyId
-  CreateModelLambdaTechnologies(subscriptionPayload, subscribeToKafka) {
+  CreateModelLambdaTechnologies(subscriptionPayload) {
     try {
       this.#lambdaModel = {};
       for (const [technologyId, technologyTelemetry] of Object.entries(subscriptionPayload.data)) {
-        this.#lambdaModel[technologyId] = ObservabilityModelUtils.GetModelForLambda(technologyId, technologyTelemetry, subscribeToKafka, this.#options.logger);
+        this.#lambdaModel[technologyId] = ObservabilityModelUtils.GetModelForLambda(technologyId, technologyTelemetry, this.#options.logger);
         if (this.#lambdaModel[technologyId] === null) {
           this.#LogDebugMessage(chalk.red(`CreateModelLambdaTechnologies():Error: GetModelForLambda() returned null`));
         }
@@ -6146,40 +5860,18 @@ class ObservabilitySubscriptionManager {
     }
   }
   //  /technologyId/subTechnologyId
-  CreateModelLambdaSubTechnologies(subscriptionPayload, subscribeToKafka) {
+  CreateModelLambdaSubTechnologies(subscriptionPayload) {
     try {
       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) {
-            this.#lambdaModel[subTechnologyId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyId, subTechnologyTelemetry, subscribeToKafka, this.#options.logger);
+            this.#lambdaModel[subTechnologyId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyId, subTechnologyTelemetry, this.#options.logger);
             if (this.#lambdaModel[subTechnologyId] !== null) {
               this.#lambdaModel[subTechnologyId].options = { technologyId };
-              if (subscribeToKafka) {
-                this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#lambdaModel[subTechnologyId]);
-                if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.AddSubscriptions([{
-                    subscriptionKey: {
-                      id: v4(),
-                      topic: SubscriptionTopic.LogProcessing,
-                      key: kafkaTopic
-                    },
-                    cb: (payload) => {
-                      this.#kafkaHelper.ProcessKafkaData(payload);
-                    }
-                  }]);
-                }
-              }
             } else {
               this.#LogDebugMessage(chalk.red(`CreateModelLambdaSubTechnologies():Error: GetModelForLambda() returned null`));
             }
-          } else {
-            if (subscribeToKafka) {
-              if (this.FindSubscriptionByKey(kafkaTopic)) {
-                this.RemoveSubscriptionsByKey(kafkaTopic);
-              }
-            }
           }
         }
       }
@@ -6188,41 +5880,19 @@ class ObservabilitySubscriptionManager {
     }
   }
   //   /technologyId/subTechnologyId/subTechnologyInstanceId
-  CreateModelLambdaSubTechnologiesInstance(subscriptionPayload, subscribeToKafka) {
+  CreateModelLambdaSubTechnologiesInstance(subscriptionPayload) {
     try {
       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) {
-              this.#lambdaModel[subTechnologyInstanceId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyInstanceId, subTechnologyInstanceTelemetry, subscribeToKafka, this.#options.logger);
+              this.#lambdaModel[subTechnologyInstanceId] = ObservabilityModelUtils.GetModelForLambda(subTechnologyInstanceId, subTechnologyInstanceTelemetry, this.#options.logger);
               if (this.#lambdaModel[subTechnologyInstanceId] !== null) {
                 this.#lambdaModel[subTechnologyInstanceId].options = { technologyId, subTechnologyId };
-                if (subscribeToKafka) {
-                  this.#kafkaHelper.GetKafkaLogData(kafkaTopic, this.#lambdaModel[subTechnologyInstanceId]);
-                  if (!this.FindSubscriptionByKey(kafkaTopic)) {
-                    this.AddSubscriptions([{
-                      subscriptionKey: {
-                        id: v4(),
-                        topic: SubscriptionTopic.LogProcessing,
-                        key: kafkaTopic
-                      },
-                      cb: (payload) => {
-                        this.#kafkaHelper.ProcessKafkaData(payload);
-                      }
-                    }]);
-                  }
-                }
               } else {
                 this.#LogDebugMessage(chalk.red(`CreateModelLambdaSubTechnologiesInstance():Error: GetModelForLambda() returned null`));
               }
-            } else {
-              if (subscribeToKafka) {
-                if (this.FindSubscriptionByKey(kafkaTopic)) {
-                  this.RemoveSubscriptionsByKey(kafkaTopic);
-                }
-              }
             }
           }
         }
@@ -6267,7 +5937,6 @@ export {
   InstrumentVelocityOptions,
   InstrumentVelocityTelemetry,
   KAFKA_PREFIX,
-  KafkaHelper,
   ObservabilityModelUtils,
   ObservabilityRESTAPISubscriber,
   ObservabilitySocketIOSubscriber,
@@ -6287,4 +5956,4 @@ export {
   runStates,
   useSTSInstrumentControllerPlugin
 };
-//# sourceMappingURL=stsobservability.mjs.map
+//# sourceMappingURL=index.mjs.map