@cap-js-community/event-queue 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "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/EventQueueProcessorBase.js

@@ -1031,7 +1031,7 @@ class EventQueueProcessorBase {
       const lockAcquired = await distributedLock.acquireLock(
         this.__context,
         [this.#namespace, this.#eventType, this.#eventSubType].join("##"),
-        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000 }
+        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000, skipNamespace: true }
       );
       if (!lockAcquired) {
         this.logger.debug("no lock available, exit processing", {
@@ -1074,7 +1074,8 @@ class EventQueueProcessorBase {
       await trace(this.baseContext, "release-lock", async () => {
         await distributedLock.releaseLock(
           this.context,
-          [this.#namespace, this.#eventType, this.#eventSubType].join("##")
+          [this.#namespace, this.#eventType, this.#eventSubType].join("##"),
+          { skipNamespace: true }
         );
       });
     } catch (err) {

package/src/runner/runner.js

@@ -180,7 +180,7 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
   }
 };
 
-const _executeEventsAllTenants = async (tenantIds, runId) => {
+const _executeEventsAllTenants = async (tenantIds) => {
   const promises = [];
   for (const tenantId of tenantIds) {
     const id = cds.utils.uuid();
@@ -230,13 +230,6 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
                 label,
                 async () => {
                   try {
-                    const lockId = `${runId}_${label}`;
-                    const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-                      expiryTime: eventQueueConfig.runInterval * 0.95,
-                    });
-                    if (!couldAcquireLock) {
-                      return;
-                    }
                     await runEventCombinationForTenant(
                       context,
                       eventConfig.type,
@@ -308,50 +301,40 @@ const _singleTenantDb = async () => {
     { newRootSpan: true }
   );
 
-  return await Promise.allSettled(
-    events.map(async (openEvent) => {
-      const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
-      const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
-      return await WorkerQueue.instance.addToQueue(
-        eventConfig.load,
-        label,
-        eventConfig.priority,
-        eventConfig.increasePriorityOverTime,
-        async () => {
-          return await cds.tx({}, async ({ context }) => {
-            await trace(
-              context,
-              label,
-              async () => {
-                try {
-                  const couldAcquireLock = eventConfig.multiInstanceProcessing
-                    ? true
-                    : await distributedLock.acquireLock(context, label, {
-                        expiryTime: eventQueueConfig.runInterval * 0.95,
-                      });
-                  if (!couldAcquireLock) {
-                    return;
+  for (const openEvent of events) {
+    const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
+    const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
+    await WorkerQueue.instance.addToQueue(
+      eventConfig.load,
+      label,
+      eventConfig.priority,
+      eventConfig.increasePriorityOverTime,
+      async () => {
+        return await cds.tx({}, async ({ context }) => {
+          await trace(
+            context,
+            label,
+            async () => {
+              try {
+                await runEventCombinationForTenant(
+                  context,
+                  eventConfig.type,
+                  eventConfig.subType,
+                  openEvent.namespace,
+                  {
+                    skipWorkerPool: true,
                   }
-                  await runEventCombinationForTenant(
-                    context,
-                    eventConfig.type,
-                    eventConfig.subType,
-                    openEvent.namespace,
-                    {
-                      skipWorkerPool: true,
-                    }
-                  );
-                } catch (err) {
-                  cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
-                }
-              },
-              { newRootSpan: true }
-            );
-          });
-        }
-      );
-    })
-  );
+                );
+              } catch (err) {
+                cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
+              }
+            },
+            { newRootSpan: true }
+          );
+        });
+      }
+    );
+  }
 };
 
 const _singleTenantRedis = async () => {
@@ -467,7 +450,7 @@ const _multiTenancyDb = async () => {
     logger.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
     await _checkPeriodicEventUpdate(tenantIds);
-    return await _executeEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
+    return await _executeEventsAllTenants(tenantIds);
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for event queue processing! Next try after defined interval.", err);
   }

package/src/shared/distributedLock.js

@@ -11,9 +11,9 @@ const COMPONENT_NAME = "/eventQueue/distributedLock";
 const acquireLock = async (
   context,
   key,
-  { tenantScoped = true, expiryTime = config.globalTxTimeout, keepTrackOfLock = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, keepTrackOfLock = false, skipNamespace = false } = {}
 ) => {
-  const fullKey = _generateKey(context, tenantScoped, key);
+  const fullKey = _generateKey(context, tenantScoped, key, skipNamespace);
   if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, { keepTrackOfLock });
   } else {
@@ -51,8 +51,8 @@ const setValueWithExpire = async (
   }
 };
 
-const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
-  const fullKey = _generateKey(context, tenantScoped, key);
+const releaseLock = async (context, key, { tenantScoped = true, skipNamespace = false } = {}) => {
+  const fullKey = _generateKey(context, tenantScoped, key, skipNamespace);
   if (config.redisEnabled) {
     return await _releaseLockRedis(context, fullKey);
   } else {
@@ -194,8 +194,8 @@ const _acquireLockDB = async (
   return result;
 };
 
-const _generateKey = (context, tenantScoped, key) => {
-  const keyParts = [config.redisNamespace()];
+const _generateKey = (context, tenantScoped, key, skipNamespace) => {
+  const keyParts = [config.redisNamespace(!skipNamespace)];
   tenantScoped && keyParts.push(context.tenant);
   keyParts.push(key);
   return `${keyParts.join("##")}`;