wsp-ms-core 1.1.24 → 1.1.27

package/dist/index.cjs

@@ -1320,8 +1320,30 @@ var EventManager = class {
     this._onReconnect = null;
   }
   async execRoute(topic, event) {
-    if (this._callbackList[topic]) {
-      await this._callbackList[topic](event);
+    console.log("[KafkaManager] execRoute START", {
+      topic
+    });
+    const callback = this._callbackList[topic];
+    if (!callback) {
+      console.log("[KafkaManager] execRoute NO CALLBACK", {
+        topic
+      });
+      return;
+    }
+    const start = Date.now();
+    try {
+      await callback(event);
+      console.log("[KafkaManager] execRoute END", {
+        topic,
+        elapsedMs: Date.now() - start
+      });
+    } catch (e) {
+      console.error("[KafkaManager] execRoute ERROR", {
+        topic,
+        elapsedMs: Date.now() - start,
+        error: e
+      });
+      throw e;
     }
   }
   async execCallback(callback, data) {
@@ -1781,10 +1803,22 @@ var KafkaManager = class extends EventManager {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.runtimeProcess = globalThis?.process;
     this.producerConnected = false;
-    this.exitingDueToLeaderError = false;
-    this.brokers = this.resolveBrokerList(this._connection.brokers ?? []);
+    this.isRecoveringLeader = false;
+    this.seedBrokers = this.resolveBrokerList(this._connection.brokers ?? []);
+    this.groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
+    this.initializeKafkaClients(this.seedBrokers);
+    this.leaderSelectionPromise = this.pinToLeaderBroker();
+  }
+  async ensureProducerConnected() {
+    await this.waitForLeaderSelection();
+    if (this.producerConnected)
+      return;
+    await this.producer.connect();
+    this.producerConnected = true;
+  }
+  initializeKafkaClients(brokers) {
     this.kafka = new import_kafkajs.Kafka({
-      brokers: this.brokers,
+      brokers,
       ssl: true,
       sasl: {
         mechanism: "scram-sha-256",
@@ -1793,16 +1827,92 @@ var KafkaManager = class extends EventManager {
       },
       logLevel: import_kafkajs.logLevel.ERROR
     });
-    const groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
-    this.consumer = this.kafka.consumer({ groupId });
+    this.consumer = this.kafka.consumer({ groupId: this.groupId });
     this.producer = this.kafka.producer();
+    this.brokers = brokers;
+    this.producerConnected = false;
     this.registerConsumerEventHandlers();
   }
-  async ensureProducerConnected() {
-    if (this.producerConnected)
+  async pinToLeaderBroker() {
+    try {
+      const leaderBroker = await this.fetchLeaderBroker(this.kafka);
+      if (!leaderBroker) {
+        console.warn("[KafkaManager] Unable to determine leader broker. Using configured list.", { brokers: this.brokers });
+        return;
+      }
+      if (this.brokers.length === 1 && this.brokers[0] === leaderBroker) {
+        return;
+      }
+      console.info("[KafkaManager] Leader broker resolved. Reinitializing clients", { leaderBroker });
+      this.initializeKafkaClients([leaderBroker]);
+    } catch (error) {
+      console.warn("[KafkaManager] Error resolving leader broker. Falling back to configured brokers.", error);
+    }
+  }
+  buildKafkaClient(brokers) {
+    return new import_kafkajs.Kafka({
+      brokers,
+      ssl: true,
+      sasl: {
+        mechanism: "scram-sha-256",
+        username: this._connection.userName,
+        password: this._connection.password
+      },
+      logLevel: import_kafkajs.logLevel.ERROR
+    });
+  }
+  async fetchLeaderBroker(kafkaClient) {
+    const admin = kafkaClient.admin();
+    try {
+      await admin.connect();
+      const cluster = await admin.describeCluster();
+      const controllerId = cluster?.controller;
+      const controller = controllerId !== void 0 ? cluster?.brokers?.find((node) => node.nodeId === controllerId) : void 0;
+      if (!controller?.host) {
+        return null;
+      }
+      const host = controller.host;
+      const port = controller.port ?? 9092;
+      return this.normalizeBroker(`${host}:${port}`);
+    } finally {
+      await admin.disconnect().catch(() => void 0);
+    }
+  }
+  async recoverFromLeaderChange(origin) {
+    if (this.isRecoveringLeader)
       return;
-    await this.producer.connect();
-    this.producerConnected = true;
+    this.isRecoveringLeader = true;
+    console.warn("[KafkaManager] Recovering from leader change", { origin, brokers: this.brokers });
+    await this.execCallback(this._onReconnect, {
+      message: "[KafkaManager] Leader change detected. Reconnecting to new leader.",
+      context: { origin }
+    });
+    try {
+      await this.stop().catch((error) => {
+        console.warn("[KafkaManager] Error stopping previous connection during recovery", error);
+      });
+      const seedClient = this.buildKafkaClient(this.seedBrokers);
+      const leaderBroker = await this.fetchLeaderBroker(seedClient).catch((error) => {
+        console.warn("[KafkaManager] Error resolving new leader broker during recovery", error);
+        return null;
+      });
+      const brokersToUse = leaderBroker ? [leaderBroker] : this.seedBrokers;
+      console.info("[KafkaManager] Reconnecting using brokers", { brokersToUse });
+      this.initializeKafkaClients(brokersToUse);
+      this.leaderSelectionPromise = Promise.resolve();
+      await this.run();
+    } catch (error) {
+      console.error("[KafkaManager] Failed to recover from leader change", { origin, error });
+      await this.execCallback(this._onError, error);
+    } finally {
+      this.isRecoveringLeader = false;
+    }
+  }
+  async waitForLeaderSelection() {
+    try {
+      await this.leaderSelectionPromise;
+    } catch {
+    }
   }
   resolveBrokerList(brokers) {
     const envBrokers = (this.runtimeProcess?.env?.KAFKA_BROKERS ?? "").split(",").map((value) => value.trim()).filter(Boolean);
@@ -1843,6 +1953,9 @@ var KafkaManager = class extends EventManager {
     this.consumer.on(events.CRASH, async (event) => {
       await this.logConsumerEvent("CRASH", event, "error");
       this.handleKafkaError(event?.payload?.error, "consumer.CRASH", { broker: event?.payload?.broker });
+      if (event?.payload?.restart === false) {
+        void this.recoverFromLeaderChange("consumer.CRASH.no-restart");
+      }
     });
     this.consumer.on(events.DISCONNECT, async (event) => {
       await this.logConsumerEvent("DISCONNECT", event, "error");
@@ -1884,8 +1997,7 @@ var KafkaManager = class extends EventManager {
       return;
     const errorType = error.type ?? error.name;
     const isNotLeaderError = errorType === "NOT_LEADER_FOR_PARTITION" || error?.name === "KafkaJSNotLeaderForPartition";
-    if (!this.exitingDueToLeaderError && isNotLeaderError) {
-      this.exitingDueToLeaderError = true;
+    if (isNotLeaderError) {
       const payload = {
         origin,
         broker: error?.broker ?? metadata?.broker,
@@ -1893,12 +2005,12 @@ var KafkaManager = class extends EventManager {
         partition: error?.partition,
         metadata
       };
-      console.error("[KafkaManager][NOT_LEADER_FOR_PARTITION] Forcing shutdown", payload);
+      console.error("[KafkaManager][NOT_LEADER_FOR_PARTITION] Reconnecting to new leader", payload);
       void this.execCallback(this._onCrash, {
-        message: "[KafkaManager] NOT_LEADER_FOR_PARTITION detected. Forcing shutdown.",
+        message: "[KafkaManager] NOT_LEADER_FOR_PARTITION detected. Reconnecting to new leader.",
         context: payload
       });
-      setTimeout(() => this.runtimeProcess?.exit?.(1), 0);
+      void this.recoverFromLeaderChange(origin);
       return;
     }
     if (error instanceof import_kafkajs.KafkaJSRequestTimeoutError || errorType === "REQUEST_TIMEOUT") {
@@ -1911,6 +2023,7 @@ var KafkaManager = class extends EventManager {
   }
   async run(autocommit = false) {
     const __run = async () => {
+      await this.waitForLeaderSelection();
       await this.execCallback(this._onStart, { message: `--- ${this.constructor.name} started ---` });
       await this.consumer.connect();
       await this.execCallback(this._onConnected, { message: `--- ${this.constructor.name} connected to ${this.brokers.join(", ")} ---` });
@@ -1926,31 +2039,70 @@ var KafkaManager = class extends EventManager {
         autoCommit: false,
         // @ts-ignore
         eachMessage: async ({ topic, partition, message, heartbeat }) => {
+          console.log("[KafkaManager] A - eachMessage START", {
+            topic,
+            partition,
+            offset: message.offset
+          });
           try {
-            await this.execCallback(this._onMessage, `[New message detected for ${topic}]: ${message.value?.toString()}`);
-            let json;
-            let event;
-            try {
-              json = JSON.parse(String(message.value?.toString()));
-              if (!json.data)
-                json.data = {};
-              event = {
-                topic: String(topic),
-                producer: String(json.producer),
-                tenant: UUID.create(String(json.tenant)),
-                message: json.data
-              };
-            } catch (error) {
-              await this.commitMessage(topic, partition, message);
-              await heartbeat();
-              throw error;
+            console.log("[KafkaManager] B - before execCallback(_onMessage)");
+            await this.execCallback(
+              this._onMessage,
+              `[New message detected for ${topic}]: ${message.value?.toString()}`
+            );
+            console.log("[KafkaManager] C - after execCallback(_onMessage)");
+            console.log("[KafkaManager] D - before JSON.parse");
+            const json = JSON.parse(message.value.toString());
+            console.log("[KafkaManager] E - after JSON.parse");
+            if (!json.data) {
+              json.data = {};
             }
+            console.log("[KafkaManager] F - before EventMessage creation");
+            const event = {
+              topic: String(topic),
+              producer: String(json.producer),
+              tenant: UUID.create(String(json.tenant)),
+              message: json.data
+            };
+            console.log("[KafkaManager] G - EventMessage created");
+            const execRouteStart = Date.now();
+            console.log("[KafkaManager] H - before execRoute", {
+              offset: message.offset
+            });
             await this.execRoute(topic, event);
+            console.log("[KafkaManager] I - after execRoute", {
+              elapsedMs: Date.now() - execRouteStart
+            });
+            const commitStart = Date.now();
+            console.log("[KafkaManager] J - before commitMessage");
             await this.commitMessage(topic, partition, message);
+            console.log("[KafkaManager] K - after commitMessage", {
+              elapsedMs: Date.now() - commitStart
+            });
+            const hbStart = Date.now();
+            console.log("[KafkaManager] L - before heartbeat");
             await heartbeat();
+            console.log("[KafkaManager] M - after heartbeat", {
+              elapsedMs: Date.now() - hbStart
+            });
+            console.log("[KafkaManager] N - eachMessage END");
           } catch (error) {
-            await this.execCallback(this._onError, error);
-            this.handleKafkaError(error, "consumer.eachMessage", { topic, partition });
+            console.error("[KafkaManager] ERROR inside eachMessage", {
+              topic,
+              partition,
+              offset: message.offset,
+              error
+            });
+            try {
+              await this.execCallback(this._onError, error);
+            } catch (callbackError) {
+              console.error("[KafkaManager] ERROR executing _onError callback", callbackError);
+            }
+            this.handleKafkaError(error, "consumer.eachMessage", {
+              topic,
+              partition,
+              offset: message.offset
+            });
             throw error;
           }
         }
@@ -1963,6 +2115,7 @@ var KafkaManager = class extends EventManager {
     }
   }
   async send(e) {
+    await this.waitForLeaderSelection();
     const evt = {
       date: DateTime.now().value,
       tenant: e.tenant.value,