wsp-ms-core 1.1.22 → 1.1.24

package/dist/index.cjs

@@ -1778,9 +1778,13 @@ var import_kafkajs = require("kafkajs");
 var KafkaManager = class extends EventManager {
   constructor(connection) {
     super(connection);
+    // 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.kafka = new import_kafkajs.Kafka({
-      brokers: this._connection.brokers,
+      brokers: this.brokers,
       ssl: true,
       sasl: {
         mechanism: "scram-sha-256",
@@ -1789,8 +1793,10 @@ var KafkaManager = class extends EventManager {
       },
       logLevel: import_kafkajs.logLevel.ERROR
     });
-    this.consumer = this.kafka.consumer({ groupId: process.env.KAFKA_GROUP || "default" });
+    const groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
+    this.consumer = this.kafka.consumer({ groupId });
     this.producer = this.kafka.producer();
+    this.registerConsumerEventHandlers();
   }
   async ensureProducerConnected() {
     if (this.producerConnected)
@@ -1798,6 +1804,107 @@ var KafkaManager = class extends EventManager {
     await this.producer.connect();
     this.producerConnected = true;
   }
+  resolveBrokerList(brokers) {
+    const envBrokers = (this.runtimeProcess?.env?.KAFKA_BROKERS ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+    const normalized = [...brokers, ...envBrokers].map((value) => this.normalizeBroker(value)).filter((value) => Boolean(value));
+    const uniqueBrokers = Array.from(new Set(normalized));
+    if (!uniqueBrokers.length) {
+      throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, "Kafka brokers configuration is empty.");
+    }
+    console.info("[KafkaManager] Using brokers", uniqueBrokers);
+    return uniqueBrokers;
+  }
+  normalizeBroker(broker) {
+    if (!broker)
+      return null;
+    const trimmed = broker.trim();
+    if (!trimmed)
+      return null;
+    if (trimmed.startsWith("PLAINTEXT://") || trimmed.startsWith("SSL://")) {
+      return trimmed;
+    }
+    return trimmed.includes(":") ? trimmed : `${trimmed}:9092`;
+  }
+  registerConsumerEventHandlers() {
+    const events = this.consumer.events;
+    this.consumer.on(events.REBALANCING, async (event) => {
+      await this.logConsumerEvent("REBALANCING", event);
+    });
+    const rebalancedEvent = this.consumer.events.REBALANCED;
+    if (rebalancedEvent) {
+      this.consumer.on(rebalancedEvent, async (event) => {
+        await this.logConsumerEvent("REBALANCED", event);
+      });
+    }
+    this.consumer.on(events.REQUEST_TIMEOUT, async (event) => {
+      await this.logConsumerEvent("REQUEST_TIMEOUT", event, "error");
+      this.handleKafkaError(event?.payload?.error, "consumer.REQUEST_TIMEOUT", { broker: event?.payload?.broker });
+    });
+    this.consumer.on(events.CRASH, async (event) => {
+      await this.logConsumerEvent("CRASH", event, "error");
+      this.handleKafkaError(event?.payload?.error, "consumer.CRASH", { broker: event?.payload?.broker });
+    });
+    this.consumer.on(events.DISCONNECT, async (event) => {
+      await this.logConsumerEvent("DISCONNECT", event, "error");
+    });
+    this.consumer.on(events.CONNECT, async (event) => {
+      await this.logConsumerEvent("CONNECT", event);
+    });
+  }
+  async logConsumerEvent(eventName, kafkaEvent, level = "info") {
+    const payload = kafkaEvent?.payload ?? {};
+    const broker = payload?.broker ?? payload?.coordinator ?? payload?.leaderId ?? null;
+    const error = payload?.error ? {
+      type: payload.error.type ?? payload.error.name,
+      message: payload.error.message
+    } : void 0;
+    const context = {
+      event: eventName,
+      timestamp: kafkaEvent?.timestamp ?? DateTime.now().value,
+      broker,
+      brokers: this.brokers,
+      groupId: payload?.groupId,
+      memberId: payload?.memberId,
+      leaderId: payload?.leaderId,
+      clientId: payload?.clientId,
+      topicPartitions: payload?.topicPartitions,
+      error
+    };
+    const message = `[KafkaManager][${eventName}] ${error?.message ?? ""}`.trim();
+    if (level === "error") {
+      console.error(message, context);
+      await this.execCallback(this._onError, { message, context });
+    } else {
+      console.info(message, context);
+      await this.execCallback(this._onReconnect, { message, context });
+    }
+  }
+  handleKafkaError(error, origin, metadata = {}) {
+    if (!error)
+      return;
+    const errorType = error.type ?? error.name;
+    const isNotLeaderError = errorType === "NOT_LEADER_FOR_PARTITION" || error?.name === "KafkaJSNotLeaderForPartition";
+    if (!this.exitingDueToLeaderError && isNotLeaderError) {
+      this.exitingDueToLeaderError = true;
+      const payload = {
+        origin,
+        broker: error?.broker ?? metadata?.broker,
+        topic: error?.topic,
+        partition: error?.partition,
+        metadata
+      };
+      console.error("[KafkaManager][NOT_LEADER_FOR_PARTITION] Forcing shutdown", payload);
+      void this.execCallback(this._onCrash, {
+        message: "[KafkaManager] NOT_LEADER_FOR_PARTITION detected. Forcing shutdown.",
+        context: payload
+      });
+      setTimeout(() => this.runtimeProcess?.exit?.(1), 0);
+      return;
+    }
+    if (error instanceof import_kafkajs.KafkaJSRequestTimeoutError || errorType === "REQUEST_TIMEOUT") {
+      console.warn("[KafkaManager][REQUEST_TIMEOUT]", { origin, metadata });
+    }
+  }
   async commitMessage(topic, partition, message) {
     const next = (BigInt(message.offset) + 1n).toString();
     await this.consumer.commitOffsets([{ topic, partition, offset: next }]);
@@ -1806,7 +1913,7 @@ var KafkaManager = class extends EventManager {
     const __run = async () => {
       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._connection.brokers} ---` });
+      await this.execCallback(this._onConnected, { message: `--- ${this.constructor.name} connected to ${this.brokers.join(", ")} ---` });
       for (let topic of this._topics) {
         try {
           await this.consumer.subscribe({ topic, fromBeginning: false });
@@ -1843,6 +1950,7 @@ var KafkaManager = class extends EventManager {
             await heartbeat();
           } catch (error) {
             await this.execCallback(this._onError, error);
+            this.handleKafkaError(error, "consumer.eachMessage", { topic, partition });
             throw error;
           }
         }
@@ -1883,9 +1991,6 @@ var KafkaManager = class extends EventManager {
     }
   }
   async start(autocommit = false) {
-    this.consumer.on(this.consumer.events.CRASH, async (error) => {
-      await this.execCallback(this._onError, new InternalError(ErrorManager.APP_ERRORS.PROCESS, error.payload.error.stack));
-    });
     await this.run();
   }
   async pause() {
@@ -2151,9 +2256,10 @@ var DefaultMysqlInboxRunner = class {
 
 // src/infrastructure/runners/default-mysql-inbox-processor.ts
 var DefaultMysqlInboxProcessor = class {
-  constructor(uowFactory) {
+  constructor(uowFactory, onError) {
     this.uovFactory = uowFactory;
     this.handlers = /* @__PURE__ */ new Map();
+    this.onError = onError;
   }
   async sleep() {
     return new Promise((r) => setTimeout(r, 5e3));
@@ -2175,6 +2281,13 @@ var DefaultMysqlInboxProcessor = class {
             record.markProcessed();
           } catch (error) {
             record.markWithError(error.toString());
+            if (this.onError) {
+              try {
+                this.onError(record, error);
+              } catch (handlerError) {
+                console.error("Error dentro del onError handler:", handlerError);
+              }
+            }
           } finally {
             await repository.update(record);
           }