@cap-js-community/event-queue 1.3.4 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "An event queue that enables secure transactional processing of asynchronous and periodic events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "files": [
@@ -70,6 +70,11 @@
     "eventQueue": {
       "[production]": {
         "disableRedis": false
+      },
+      "[test]": {
+        "registerAsEventProcessor": false,
+        "isRunnerDeactivated": true,
+        "updatePeriodicEvents": false
       }
     },
     "requires": {

package/src/redisPubSub.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { promisify } = require("util");
+
 const cds = require("@sap/cds");
 
 const redis = require("./shared/redis");
@@ -10,7 +12,10 @@ const { getSubdomainForTenantId } = require("./shared/cdsHelper");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/redisPubSub";
+const TRIES_FOR_PUBLISH_PERIODIC_EVENT = 10;
+const SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT = 30 * 1000;
 
+const wait = promisify(setTimeout);
 let subscriberClientPromise;
 
 const initEventQueueRedisSubscribe = () => {
@@ -107,23 +112,34 @@ const broadcastEvent = async (tenantId, type, subType) => {
       }
       return;
     }
-    const result = await checkLockExistsAndReturnValue(
-      new cds.EventContext({ tenant: tenantId }),
-      [type, subType].join("##")
-    );
-    if (result) {
-      logger.debug("skip publish redis event as no lock is available", {
+    const eventConfig = config.getEventConfig(type, subType);
+    for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
+      const result = await checkLockExistsAndReturnValue(
+        new cds.EventContext({ tenant: tenantId }),
+        [type, subType].join("##")
+      );
+      if (result) {
+        logger.debug("skip publish redis event as no lock is available", {
+          type,
+          subType,
+          index: i,
+          isPeriodic: eventConfig.isPeriodic,
+          waitInterval: SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT,
+        });
+        if (!eventConfig.isPeriodic) {
+          break;
+        }
+        await wait(SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT);
+        continue;
+      }
+      logger.debug("publishing redis event", {
+        tenantId,
         type,
         subType,
       });
-      return;
+      await redis.publishMessage(EVENT_MESSAGE_CHANNEL, JSON.stringify({ tenantId, type, subType }));
+      break;
     }
-    logger.debug("publishing redis event", {
-      tenantId,
-      type,
-      subType,
-    });
-    await redis.publishMessage(EVENT_MESSAGE_CHANNEL, JSON.stringify({ tenantId, type, subType }));
   } catch (err) {
     logger.error("publish event failed!", err, {
       tenantId,

package/src/runner.js

@@ -68,19 +68,23 @@ const _scheduleFunction = async (singleRunFn, periodicFn) => {
 
 const _multiTenancyRedis = async () => {
   const logger = cds.log(COMPONENT_NAME);
-  const emptyContext = new cds.EventContext({});
-  logger.info("executing event queue run for multi instance and tenant");
-  const tenantIds = await cdsHelper.getAllTenantIds();
-  await _checkPeriodicEventUpdate(tenantIds);
+  try {
+    const emptyContext = new cds.EventContext({});
+    logger.info("executing event queue run for multi instance and tenant");
+    const tenantIds = await cdsHelper.getAllTenantIds();
+    await _checkPeriodicEventUpdate(tenantIds);
 
-  const runId = await _acquireRunId(emptyContext);
+    const runId = await _acquireRunId(emptyContext);
 
-  if (!runId) {
-    logger.error("could not acquire runId, skip processing events!");
-    return;
-  }
+    if (!runId) {
+      logger.error("could not acquire runId, skip processing events!");
+      return;
+    }
 
-  return await _executeEventsAllTenants(tenantIds, runId);
+    return await _executeEventsAllTenants(tenantIds, runId);
+  } catch (err) {
+    logger.info("executing event queue run for multi instance and tenant failed", err);
+  }
 };
 
 const _checkPeriodicEventUpdate = async (tenantIds) => {

package/src/shared/redis.js

@@ -6,9 +6,11 @@ const { getEnvInstance } = require("./env");
 const EventQueueError = require("../EventQueueError");
 
 const COMPONENT_NAME = "/eventQueue/shared/redis";
+const LOG_AFTER_SEC = 5;
 
 let mainClientPromise;
 const subscriberChannelClientPromise = {};
+let lastErrorLog = Date.now();
 
 const createMainClientAndConnect = () => {
   if (mainClientPromise) {
@@ -18,8 +20,9 @@ const createMainClientAndConnect = () => {
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
     mainClientPromise = null;
-    setTimeout(createMainClientAndConnect, 5 * 1000).unref();
+    setTimeout(createMainClientAndConnect, LOG_AFTER_SEC * 1000).unref();
   };
+
   mainClientPromise = createClientAndConnect(errorHandlerCreateClient);
   return mainClientPromise;
 };
@@ -47,29 +50,37 @@ const _createClientBase = () => {
 };
 
 const createClientAndConnect = async (errorHandlerCreateClient) => {
-  let client = null;
-  try {
-    client = _createClientBase();
-  } catch (err) {
-    throw EventQueueError.redisConnectionFailure(err);
-  }
-
-  client.on("error", errorHandlerCreateClient);
-
   try {
+    const client = _createClientBase();
     await client.connect();
+    client.on("error", (err) => {
+      const dateNow = Date.now();
+      if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
+        cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
+        lastErrorLog = dateNow;
+      }
+    });
+
+    client.on("reconnecting", () => {
+      const dateNow = Date.now();
+      if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
+        cds.log(COMPONENT_NAME).info("redis client trying reconnect...");
+        lastErrorLog = dateNow;
+      }
+    });
+    return client;
   } catch (err) {
     errorHandlerCreateClient(err);
   }
-  return client;
 };
 
 const subscribeRedisChannel = (channel, subscribeHandler) => {
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error(`error from redis client for pub/sub failed for channel ${channel}`, err);
     subscriberChannelClientPromise[channel] = null;
-    setTimeout(() => subscribeRedisChannel(channel, subscribeHandler), 5 * 1000).unref();
+    setTimeout(() => subscribeRedisChannel(channel, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
   };
+
   subscriberChannelClientPromise[channel] = createClientAndConnect(errorHandlerCreateClient)
     .then((client) => {
       cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });