@cap-js-community/event-queue 1.7.1 → 1.7.3

package/cds-plugin.js

@@ -4,6 +4,7 @@ const cds = require("@sap/cds");
 const cdsPackage = require("@sap/cds/package.json");
 
 const eventQueue = require("./src");
+const EventQueueError = require("./src/EventQueueError");
 const COMPONENT_NAME = "/eventQueue/plugin";
 const SERVE_COMMAND = "serve";
 
@@ -18,5 +19,10 @@ if ((doLegacyBuildDetection && isBuild) || (!doLegacyBuildDetection && !isServe)
 }
 
 if (Object.keys(cds.env.eventQueue ?? {}).length) {
-  module.exports = eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
+  module.exports = eventQueue.initialize().catch((err) => {
+    if (EventQueueError.isRedisConnectionFailure(err) && eventQueue.config.crashOnRedisUnavailable) {
+      throw err;
+    }
+    cds.log(COMPONENT_NAME).error(err);
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "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",
   "types": "src/index.d.ts",

package/src/EventQueueError.js

@@ -41,7 +41,7 @@ const ERROR_CODES_META = {
     message: "error during create client with redis-cache service",
   },
   [ERROR_CODES.REDIS_LOCAL_NO_RECONNECT]: {
-    message: "disabled reconnect, because we are not running on cloud foundry",
+    message: "disabled reconnect, because not running on cloud foundry",
   },
   [ERROR_CODES.MISSING_TABLE_DEFINITION]: {
     message: "Could not find table in csn. Make sure the provided table name is correct and the table is known by CDS.",
@@ -135,7 +135,7 @@ class EventQueueError extends VError {
     return new EventQueueError(
       {
         name: ERROR_CODES.REDIS_CREATE_CLIENT,
-        cause: err,
+        ...(err && { cause: err }),
       },
       message
     );
@@ -325,6 +325,10 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static isRedisConnectionFailure(err) {
+    return err instanceof VError && err.name === ERROR_CODES.REDIS_CREATE_CLIENT;
+  }
 }
 
 module.exports = EventQueueError;

package/src/config.js

@@ -77,6 +77,7 @@ class Config {
   #unsubscribedTenants = {};
   #cronTimezone;
   #publishEventBlockList;
+  #crashOnRedisUnavailable;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -510,6 +511,14 @@ class Config {
     this.#publishEventBlockList = value;
   }
 
+  get crashOnRedisUnavailable() {
+    return this.#crashOnRedisUnavailable;
+  }
+
+  set crashOnRedisUnavailable(value) {
+    this.#crashOnRedisUnavailable = value;
+  }
+
   set globalTxTimeout(value) {
     this.#globalTxTimeout = value;
   }

package/src/index.d.ts

@@ -182,6 +182,8 @@ declare class Config {
   hasEventAfterCommitFlag(type: string, subType: string): boolean;
   _checkRedisIsBound(): boolean;
   checkRedisEnabled(): boolean;
+  publishEventBlockList(): boolean;
+  crashOnRedisUnavailable(): boolean;
   attachConfigChangeHandler(): void;
   attachRedisUnsubscribeHandler(): void;
   executeUnsubscribeHandlers(tenantId: string): void;

package/src/initialize.js

@@ -16,6 +16,7 @@ const eventQueueAsOutbox = require("./outbox/eventQueueAsOutbox");
 const { getAllTenantIds } = require("./shared/cdsHelper");
 const { EventProcessingStatus } = require("./constants");
 const distributedLock = require("./shared/distributedLock");
+const EventQueueError = require("./EventQueueError");
 
 const readFileAsync = promisify(fs.readFile);
 
@@ -39,6 +40,7 @@ const CONFIG_VARS = [
   ["enableCAPTelemetry", false],
   ["cronTimezone", null],
   ["publishEventBlockList", true],
+  ["crashOnRedisUnavailable", false],
 ];
 
 /**
@@ -61,6 +63,7 @@ const CONFIG_VARS = [
  * @param {boolean} [options.enableCAPTelemetry=false] - Enable telemetry for CAP.
  * @param {string} [options.cronTimezone=null] - Default timezone for cron jobs.
  * @param {string} [options.publishEventBlockList=true] - If redis is available event blocklist is distributed to all application instances
+ * @param {string} [options.crashOnRedisUnavailable=true] - If enabled an error is thrown if the redis connection check is not successful
  */
 const initialize = async (options = {}) => {
   if (config.initialized) {
@@ -71,6 +74,12 @@ const initialize = async (options = {}) => {
   mixConfigVarsWithEnv(options);
 
   const logger = cds.log(COMPONENT);
+  if (!config.useAsCAPOutbox && !config.configFilePath) {
+    logger.info(
+      "Event queue initialization skipped: no configFilePath provided, and event queue is not configured as a CAP outbox."
+    );
+  }
+
   const redisEnabled = config.checkRedisEnabled();
   let resolveFn;
   let initFinished = new Promise((resolve) => (resolveFn = resolve));
@@ -83,6 +92,9 @@ const initialize = async (options = {}) => {
   });
   if (redisEnabled) {
     config.redisEnabled = await redis.connectionCheck(config.redisOptions);
+    if (!config.redisEnabled && config.crashOnRedisUnavailable) {
+      throw EventQueueError.redisConnectionFailure();
+    }
   }
   config.fileContent = await readConfigFromFile(config.configFilePath);
 
@@ -133,17 +145,21 @@ const registerEventProcessors = () => {
 
   const errorHandler = (err) => cds.log(COMPONENT).error("error during init runner", err);
 
-  if (!config.isMultiTenancy) {
-    runner.singleTenant().catch(errorHandler);
-    return;
-  }
-
   if (config.redisEnabled) {
     initEventQueueRedisSubscribe();
     config.attachConfigChangeHandler();
-    runner.multiTenancyRedis().catch(errorHandler);
-  } else {
+    if (config.isMultiTenancy) {
+      runner.multiTenancyRedis().catch(errorHandler);
+    } else {
+      runner.singleTenantRedis().catch(errorHandler);
+    }
+    return;
+  }
+
+  if (config.isMultiTenancy) {
     runner.multiTenancyDb().catch(errorHandler);
+  } else {
+    runner.singleTenantDb().catch(errorHandler);
   }
 };
 

package/src/periodicEvents.js

@@ -122,7 +122,7 @@ const _determineChangedCron = (existingEventsCron) => {
       utc: config.utc,
       ...(config.useCronTimezone && { tz: eventConfig.cronTimezone }),
     });
-    return cronExpression.next().getTime() - eventStartAfter.getTime() > 30 * 1000; // report as changed if diff created than 30 seconds
+    return Math.abs(cronExpression.next().getTime() - eventStartAfter.getTime()) > 30 * 1000; // report as changed if diff created than 30 seconds
   });
 };
 
@@ -133,12 +133,13 @@ const _insertPeriodEvents = async (tx, events, now) => {
   const eventsToBeInserted = events.map((event) => {
     const base = { type: event.type, subType: event.subType };
     let startTime = now;
-    if (event.cron) {
+    const config = eventConfig.getEventConfig(event.type, event.subType);
+    if (config.cron) {
       startTime = cronParser
-        .parseExpression(event.cron, {
+        .parseExpression(config.cron, {
           currentDate: now,
-          utc: event.utc,
-          ...(event.useCronTimezone && { tz: eventConfig.cronTimezone }),
+          utc: config.utc,
+          ...(config.useCronTimezone && { tz: eventConfig.cronTimezone }),
         })
         .next();
     }

package/src/runner/runner.js

@@ -27,12 +27,14 @@ let OFFSET_FIRST_RUN = 10 * 1000;
 let tenantIdHash;
 let singleRunDone;
 
-const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantDb);
+const singleTenantDb = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantDb);
 
 const multiTenancyDb = () => _scheduleFunction(async () => {}, _multiTenancyDb);
 
 const multiTenancyRedis = () => _scheduleFunction(async () => {}, _multiTenancyRedis);
 
+const singleTenantRedis = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantRedis);
+
 const _scheduleFunction = async (singleRunFn, periodicFn) => {
   const logger = cds.log(COMPONENT_NAME);
   const eventsForAutomaticRun = eventQueueConfig.allEvents;
@@ -300,6 +302,54 @@ const _singleTenantDb = async () => {
   );
 };
 
+const _singleTenantRedis = async () => {
+  const id = cds.utils.uuid();
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    // NOTE: do checks for open events on one app instance distribute from this instance to all others
+    const dummyContext = new cds.EventContext({});
+    const couldAcquireLock = await trace(
+      dummyContext,
+      "acquire-lock-master-runner",
+      async () => {
+        return await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_RUN_REDIS_CHECK, {
+          expiryTime: eventQueueConfig.runInterval * 0.95,
+          tenantScoped: false,
+        });
+      },
+      { newRootSpan: true }
+    );
+    if (!couldAcquireLock) {
+      return;
+    }
+
+    await trace(
+      { id },
+      "get-openEvents-and-publish",
+      async () => {
+        return await cds.tx({}, async (tx) => {
+          const entries = await openEvents.getOpenQueueEntries(tx);
+          logger.info("broadcasting events for run", {
+            entries: entries.length,
+          });
+          if (!entries.length) {
+            return;
+          }
+          // Do not wait until this is finished - as broadcastEvent has a retry mechanism and can delay this loop
+          redisPub.broadcastEvent(null, entries).catch((err) => {
+            logger.error("broadcasting event failed", err, {
+              entries: entries.length,
+            });
+          });
+        });
+      },
+      { newRootSpan: true }
+    );
+  } catch (err) {
+    logger.info("executing event queue run for single tenant via redis", err);
+  }
+};
+
 const _acquireRunId = async (context) => {
   let runId = randomUUID();
   const couldSetValue = await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_ID, runId, {
@@ -401,9 +451,33 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
   }
 };
 
-const _checkPeriodicEventsSingleTenantOneTime = async () =>
-  eventQueueConfig.updatePeriodicEvents &&
-  cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));
+const _checkPeriodicEventsSingleTenantOneTime = async () => {
+  const logger = cds.log(COMPONENT_NAME);
+  if (!eventQueueConfig.updatePeriodicEvents || !eventQueueConfig.periodicEvents.length) {
+    logger.info("updating of periodic events is disabled or no periodic events configured", {
+      updateEnabled: eventQueueConfig.updatePeriodicEvents,
+      events: eventQueueConfig.periodicEvents.length,
+    });
+    return;
+  }
+
+  const dummyContext = new cds.EventContext({});
+  return await trace(
+    dummyContext,
+    "update-periodic-events",
+    async () => {
+      const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+        expiryTime: 60 * 1000,
+        tenantScoped: false,
+      });
+      if (!couldAcquireLock) {
+        return;
+      }
+      return await cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));
+    },
+    { newRootSpan: true }
+  );
+};
 
 const _checkPeriodicEventsSingleTenant = async (context) => {
   const logger = cds.log(COMPONENT_NAME);
@@ -429,12 +503,14 @@ const _checkPeriodicEventsSingleTenant = async (context) => {
 };
 
 module.exports = {
-  singleTenant,
+  singleTenantDb,
   multiTenancyDb,
   multiTenancyRedis,
+  singleTenantRedis,
   __: {
     _singleTenantDb,
     _multiTenancyRedis,
+    _singleTenantRedis,
     _multiTenancyDb,
     _calculateOffsetForFirstRun,
     _acquireRunId,

package/src/shared/common.js

@@ -87,6 +87,10 @@ const _getNewAuthInfo = async (tenantId) => {
 };
 
 const getAuthInfo = async (tenantId) => {
+  if (!tenantId) {
+    return null;
+  }
+
   if (!cds.requires?.auth?.credentials) {
     return null; // no credentials not authInfo
   }

package/src/shared/redis.js

@@ -50,25 +50,27 @@ const _createClientBase = (redisOptions) => {
   }
 };
 
-const createClientAndConnect = async (options, errorHandlerCreateClient) => {
+const createClientAndConnect = async (options, errorHandlerCreateClient, isConnectionCheck) => {
   try {
     const client = _createClientBase(options);
-    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;
-      }
-    });
+    if (!isConnectionCheck) {
+      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;
-      }
-    });
+      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;
+        }
+      });
+    }
+    await client.connect();
     return client;
   } catch (err) {
     errorHandlerCreateClient(err);
@@ -119,7 +121,7 @@ const _resilientClientClose = async (client) => {
 
 const connectionCheck = async (options) => {
   return new Promise((resolve, reject) => {
-    createClientAndConnect(options, reject)
+    createClientAndConnect(options, reject, true)
       .then((client) => {
         if (client) {
           _resilientClientClose(client);
@@ -131,7 +133,10 @@ const connectionCheck = async (options) => {
       .catch(reject);
   })
     .then(() => true)
-    .catch(() => false);
+    .catch((err) => {
+      cds.log(COMPONENT_NAME).error("Redis connection check failed! Falling back to NO_REDIS mode", err);
+      return false;
+    });
 };
 
 module.exports = {