@cap-js-community/event-queue 1.10.6 → 1.10.8

package/db/Lock.cds

@@ -1,6 +1,5 @@
 namespace sap.eventqueue;
 
-using cuid from '@sap/cds/common';
 using managed from '@sap/cds/common';
 
 @assert.unique.semanticKey: [code]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "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",
@@ -55,10 +55,10 @@
   },
   "devDependencies": {
     "@cap-js/cds-test": "^0.3.0",
-    "@cap-js/hana": "^1.8.0",
-    "@cap-js/sqlite": "^1.10.0",
-    "@sap/cds": "^8.9.0",
-    "@sap/cds-dk": "^8.8.0",
+    "@cap-js/hana": "^2.1.0",
+    "@cap-js/sqlite": "^2.0.1",
+    "@sap/cds": "^9.0.3",
+    "@sap/cds-dk": "^9.0.4",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",

package/src/EventQueueProcessorBase.js

@@ -1016,7 +1016,7 @@ class EventQueueProcessorBase {
 
     // NOTE: do not pass current date as we always want to calc. a future date
     const cronExpression = CronExpressionParser.parse(this.#eventConfig.cron, {
-      tz: eventConfig.tz,
+      tz: this.#eventConfig.tz,
     });
     return cronExpression.next();
   }

package/src/config.js

@@ -28,6 +28,7 @@ const DEFAULT_CHECK_FOR_NEXT_CHUNK = true;
 const SUFFIX_PERIODIC = "_PERIODIC";
 const CAP_EVENT_TYPE = "CAP_OUTBOX";
 const CAP_PARALLEL_DEFAULT = 5;
+const CAP_MAX_ATTEMPTS_DEFAULT = 5;
 const DELETE_TENANT_BLOCK_AFTER_MS = 5 * 60 * 1000;
 const PRIORITIES = Object.values(Priorities);
 const UTC_DEFAULT = false;
@@ -387,7 +388,7 @@ class Config {
       kind: config.kind ?? "persistent-outbox",
       selectMaxChunkSize: config.selectMaxChunkSize ?? config.chunkSize,
       parallelEventProcessing: config.parallelEventProcessing ?? (config.parallel && CAP_PARALLEL_DEFAULT),
-      retryAttempts: config.retryAttempts ?? config.maxAttempts,
+      retryAttempts: config.retryAttempts ?? config.maxAttempts ?? CAP_MAX_ATTEMPTS_DEFAULT,
       ...config,
     });
     eventConfig.internalEvent = true;

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -61,7 +61,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
         }
       } else {
         for (const actionName in genericClusterEvents) {
-          const msg = new cds.Request({
+          const reg = new cds.Request({
             event: EVENT_QUEUE_ACTIONS.CLUSTER,
             user: this.context.user,
             eventQueue: {
@@ -74,14 +74,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
                 this.#clusterByDataProperty(actionName, genericClusterEvents[actionName], propertyName, cb),
             },
           });
-          const clusterResult = await this.__srvUnboxed.tx(this.context).send(msg);
+          const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
           if (this.#validateCluster(clusterResult)) {
             Object.assign(clusterMap, clusterResult);
           } else {
             this.logger.error(
               "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
               {
-                handler: msg.event,
+                handler: reg.event,
                 clusterResult: JSON.stringify(clusterResult),
               }
             );
@@ -92,7 +92,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     }
 
     for (const actionName in specificClusterEvents) {
-      const msg = new cds.Request({
+      const reg = new cds.Request({
         event: `${EVENT_QUEUE_ACTIONS.CLUSTER}.${actionName}`,
         user: this.context.user,
         eventQueue: {
@@ -105,14 +105,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
             this.#clusterByDataProperty(actionName, specificClusterEvents[actionName], propertyName, cb),
         },
       });
-      const clusterResult = await this.__srvUnboxed.tx(this.context).send(msg);
+      const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
       if (this.#validateCluster(clusterResult)) {
         Object.assign(clusterMap, clusterResult);
       } else {
         this.logger.error(
           "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
           {
-            handler: msg.event,
+            handler: reg.event,
             clusterResult: JSON.stringify(clusterResult),
           }
         );
@@ -264,12 +264,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return payload;
     }
 
-    const { msg, userId } = this.#buildDispatchData(this.context, payload, {
+    const { reg, userId } = this.#buildDispatchData(this.context, payload, {
       queueEntries: [queueEntry],
     });
-    msg.event = handlerName;
-    await this.#setContextUser(this.context, userId, msg);
-    const data = await this.__srvUnboxed.tx(this.context).send(msg);
+    reg.event = handlerName;
+    await this.#setContextUser(this.context, userId, reg);
+    const data = await this.__srvUnboxed.tx(this.context).send(reg);
     if (data) {
       payload.data = data;
       return payload;
@@ -285,12 +285,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return await super.hookForExceededEvents(exceededEvent);
     }
 
-    const { msg, userId } = this.#buildDispatchData(this.context, exceededEvent.payload, {
+    const { reg, userId } = this.#buildDispatchData(this.context, exceededEvent.payload, {
       queueEntries: [exceededEvent],
     });
-    await this.#setContextUser(this.context, userId, msg);
-    msg.event = handlerName;
-    await this.__srvUnboxed.tx(this.context).send(msg);
+    await this.#setContextUser(this.context, userId, reg);
+    reg.event = handlerName;
+    await this.__srvUnboxed.tx(this.context).send(reg);
   }
 
   // NOTE: Currently not exposed to CAP service; we wait for a valid use case
@@ -310,37 +310,37 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
 
   async processPeriodicEvent(processContext, key, queueEntry) {
     const [, action] = this.eventSubType.split(".");
-    const msg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
-    await this.#setContextUser(processContext, config.userId, msg);
-    await this.__srvUnboxed.tx(processContext).emit(msg);
+    const reg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    await this.#setContextUser(processContext, config.userId, reg);
+    await this.__srvUnboxed.tx(processContext).emit(reg);
   }
 
   #buildDispatchData(context, payload, { key, queueEntries } = {}) {
     const { useEventQueueUser } = this.eventConfig;
     const userId = useEventQueueUser ? config.userId : payload.contextUser;
-    const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
+    const reg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
     const invocationFn = payload._fromSend ? "send" : "emit";
-    delete msg._fromSend; // TODO: this changes the source object --> check after multiple invocations
-    delete msg.contextUser;
-    msg.eventQueue = { processor: this, key, queueEntries, payload };
-    return { msg, userId, invocationFn };
+    delete reg._fromSend;
+    delete reg.contextUser;
+    reg.eventQueue = { processor: this, key, queueEntries, payload };
+    return { reg, userId, invocationFn };
   }
 
-  async #setContextUser(context, userId, data) {
+  async #setContextUser(context, userId, reg) {
     context.user = new cds.User.Privileged({
       id: userId,
       tokenInfo: await common.getTokenInfo(this.baseContext.tenant),
     });
-    if (data) {
-      data.user = context.user;
+    if (reg) {
+      reg.user = context.user;
     }
   }
 
   async processEvent(processContext, key, queueEntries, payload) {
     try {
-      const { userId, invocationFn, msg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
-      await this.#setContextUser(processContext, userId, msg);
-      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](msg);
+      const { userId, invocationFn, reg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
+      await this.#setContextUser(processContext, userId, reg);
+      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](reg);
       return this.#determineResultStatus(result, queueEntries);
     } catch (err) {
       this.logger.error("error processing outboxed service call", err, {

package/src/outbox/eventQueueAsOutbox.js

@@ -52,7 +52,7 @@ function outboxed(srv, customOpts) {
       outboxOpts = config.addCAPOutboxEventSpecificAction(srv.name, req.event);
     }
 
-    if (outboxOpts.kind === "persistent-outbox") {
+    if (["persistent-outbox", "persistent-queue"].includes(outboxOpts.kind)) {
       await _mapToEventAndPublish(context, srv.name, req, !!specificSettings);
       return;
     }

package/src/periodicEvents.js

@@ -7,9 +7,12 @@ const { EventProcessingStatus } = require("./constants");
 const { processChunkedSync } = require("./shared/common");
 const eventConfig = require("./config");
 
-const COMPONENT_NAME = "/eventQueue/periodicEvents";
 const CHUNK_SIZE_INSERT_PERIODIC_EVENTS = 4;
 
+const ALLOWED_PERIODIC_SEC_DIFF = 30;
+
+const COMPONENT_NAME = "/eventQueue/periodicEvents";
+
 const checkAndInsertPeriodicEvents = async (context) => {
   const now = new Date();
   const tx = cds.tx(context);
@@ -117,11 +120,16 @@ const _determineChangedCron = (existingEventsCron) => {
     const config = eventConfig.getEventConfig(event.type, event.subType);
     const eventStartAfter = new Date(event.startAfter);
     const eventCreatedAt = new Date(event.createdAt);
+    const randomOffset = config.randomOffset ?? eventConfig.randomOffsetPeriodicEvents ?? 0;
     const cronExpression = CronExpressionParser.parse(config.cron, {
       currentDate: eventCreatedAt,
       tz: config.tz,
     });
-    return Math.abs(cronExpression.next().getTime() - eventStartAfter.getTime()) > 30 * 1000; // report as changed if diff created than 30 seconds
+    // report as changed if diff created than ALLOWED_PERIODIC_SEC_DIFF + the random event offset seconds
+    return (
+      Math.abs(cronExpression.next().getTime() - eventStartAfter.getTime()) >
+      (ALLOWED_PERIODIC_SEC_DIFF + randomOffset) * 1000
+    );
   });
 };
 

package/src/processEventQueue.js

@@ -318,8 +318,11 @@ const _checkEventIsBlocked = async (baseInstance) => {
 
 const _processEvent = async (eventTypeInstance, processContext, key, queueEntries, payload) => {
   let traceContext;
-  if (queueEntries.length === 1 && eventTypeInstance.inheritTraceContext) {
-    traceContext = queueEntries[0].context?.traceContext;
+  if (eventTypeInstance.inheritTraceContext) {
+    const uniqueTraceContext = [...new Set(queueEntries.map((entry) => entry.context?.traceContext).filter((a) => a))];
+    if (uniqueTraceContext.length === 1) {
+      traceContext = uniqueTraceContext[0];
+    }
   }
 
   return await trace(

package/src/runner/openEvents.js

@@ -38,34 +38,33 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   for (const { type, subType } of entries) {
     if (eventConfig.isCapOutboxEvent(type)) {
       const [srvName, actionName] = subType.split(".");
-      cds.connect
-        .to(srvName)
-        .then((service) => {
-          if (!filterAppSpecificEvents) {
-            return; // will be done in finally
-          }
+      try {
+        const service = await cds.connect.to(srvName);
+        if (!filterAppSpecificEvents) {
+          return; // will be done in finally
+        }
 
-          if (!service) {
-            return;
-          }
-          cds.outboxed(service);
-          if (actionName) {
-            config.addCAPOutboxEventSpecificAction(srvName, actionName);
-          }
-          if (filterAppSpecificEvents) {
-            if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
-              result.push({ type, subType });
-            }
-          } else {
-            result.push({ type, subType });
-          }
-        })
-        .catch(() => {})
-        .finally(() => {
-          if (!filterAppSpecificEvents) {
+        if (!service) {
+          return;
+        }
+        cds.outboxed(service);
+        if (actionName) {
+          config.addCAPOutboxEventSpecificAction(srvName, actionName);
+        }
+        if (filterAppSpecificEvents) {
+          if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
             result.push({ type, subType });
           }
-        });
+        } else {
+          result.push({ type, subType });
+        }
+      } catch {
+        /* ignore catch */
+      } finally {
+        if (!filterAppSpecificEvents) {
+          result.push({ type, subType });
+        }
+      }
     } else {
       if (filterAppSpecificEvents) {
         if (

package/src/runner/runner.js

@@ -138,8 +138,12 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
     if (!couldAcquireLock) {
       return;
     }
+  } catch (err) {
+    logger.error("executing event queue run for multi instance and tenant failed", err);
+  }
 
-    for (const tenantId of tenantIds) {
+  for (const tenantId of tenantIds) {
+    try {
       await cds.tx({ tenant: tenantId }, async (tx) => {
         await trace(
           tx.context,
@@ -168,9 +172,9 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
           { newRootSpan: true }
         );
       });
+    } catch (err) {
+      logger.error("broadcasting events for tenant failed", { tenantId }, err);
     }
-  } catch (err) {
-    logger.info("executing event queue run for multi instance and tenant failed", err);
   }
 };
 
@@ -179,23 +183,29 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
   for (const tenantId of tenantIds) {
     const id = cds.utils.uuid();
     let tenantContext;
-    const events = await trace(
-      { id, tenant: tenantId },
-      "fetch-openEvents-and-tokenInfo",
-      async () => {
-        const user = await cds.tx({ tenant: tenantId }, async () => {
-          return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
-        });
-        tenantContext = {
-          tenant: tenantId,
-          user,
-        };
-        return await cds.tx(tenantContext, async (tx) => {
-          return await openEvents.getOpenQueueEntries(tx);
-        });
-      },
-      { newRootSpan: true }
-    );
+    let events;
+    try {
+      events = await trace(
+        { id, tenant: tenantId },
+        "fetch-openEvents-and-tokenInfo",
+        async () => {
+          const user = await cds.tx({ tenant: tenantId }, async () => {
+            return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
+          });
+          tenantContext = {
+            tenant: tenantId,
+            user,
+          };
+          return await cds.tx(tenantContext, async (tx) => {
+            return await openEvents.getOpenQueueEntries(tx);
+          });
+        },
+        { newRootSpan: true }
+      );
+    } catch (err) {
+      cds.log(COMPONENT_NAME).error("fetching open events for tenant failed", { tenantId }, err);
+      continue;
+    }
 
     if (!events.length) {
       continue;

package/src/shared/distributedLock.js

@@ -108,7 +108,7 @@ const _renewLockRedis = async (context, fullKey, expiryTime, { value = "true" }
 
 const _checkLockExistsRedis = async (context, fullKey) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
-  return await client.get(fullKey);
+  return await client.exists(fullKey);
 };
 
 const _checkLockExistsDb = async (context, fullKey) => {
@@ -191,43 +191,45 @@ const _generateKey = (context, tenantScoped, key) => {
 };
 
 const getAllLocksRedis = async () => {
-  const client = await redis.createMainClientAndConnect(config.redisOptions);
-  const keys = await client.keys(`${config.redisOptions.redisNamespace}*`);
-  const relevantKeys = {};
-  for (const key of keys) {
-    const [, tenant, guidOrType, subType] = key.split("##");
-    if (subType) {
-      relevantKeys[key] = { tenant, guidOrType, subType };
-    }
-  }
+  const clientOrCluster = await redis.createMainClientAndConnect(config.redisOptions);
+  const output = [];
+  const results = [];
 
-  if (!Object.keys(relevantKeys)) {
-    return [];
+  let clients;
+  if (redis.isClusterMode()) {
+    clients = clientOrCluster.masters.map((master) => master.client);
+  } else {
+    clients = [clientOrCluster];
   }
 
-  const pipeline = client.multi();
-  for (const key in relevantKeys) {
-    pipeline.ttl(key);
-    pipeline.get(key);
-  }
+  // NOTE: use SCAN because KEYS is not supported for cluster clients
+  for (const client of clients) {
+    for await (const key of client.scanIterator({ MATCH: "EVENT*", COUNT: 1000 })) {
+      const [, tenant, guidOrType, subType] = key.split("##");
+      if (!subType) {
+        continue;
+      }
 
-  const replies = await pipeline.exec();
+      const pipeline = client.multi();
+      output.push({
+        tenant: tenant,
+        type: guidOrType,
+        subType: subType,
+      });
+      pipeline.ttl(key).get(key);
+      const replies = await pipeline.exec();
+      results.push(...replies);
+    }
+  }
 
   let counter = 0;
-  const result = [];
-  for (const value of Object.values(relevantKeys)) {
-    const ttl = replies[counter];
-    const createdAt = replies[counter + 1];
-    result.push({
-      tenant: value.tenant,
-      type: value.guidOrType,
-      subType: value.subType,
-      ttl,
-      createdAt,
-    });
+  for (const row of output) {
+    const ttl = results[counter];
+    const createdAt = results[counter + 1];
+    Object.assign(row, { ttl, createdAt });
     counter = counter + 2;
   }
-  return result;
+  return output;
 };
 
 const shutdownHandler = async () => {

package/src/shared/redis.js

@@ -178,6 +178,15 @@ const connectionCheck = async (options) => {
     });
 };
 
+const isClusterMode = () => {
+  if (!("__clusterMode" in isClusterMode)) {
+    const env = getEnvInstance();
+    const { credentials } = env.redisRequires;
+    isClusterMode.__clusterMode = credentials.cluster_mode;
+  }
+  return isClusterMode.__clusterMode;
+};
+
 module.exports = {
   createClientAndConnect,
   createMainClientAndConnect,
@@ -186,4 +195,5 @@ module.exports = {
   closeMainClient,
   closeSubscribeClient,
   connectionCheck,
+  isClusterMode,
 };

package/srv/service/admin-service.cds

@@ -23,6 +23,7 @@ service EventQueueAdminService {
   }
 
   @cds.persistence.skip
+  @readonly
   entity Lock {
     key tenant: String;
     key type: String;