@cap-js-community/event-queue 0.2.5 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "An event queue that enables secure transactional processing of asynchronous events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "files": [

package/src/config.js

@@ -12,6 +12,7 @@ const REDIS_CONFIG_CHANNEL = "EVENT_QUEUE_CONFIG_CHANNEL";
 const COMPONENT_NAME = "eventQueue/config";
 const MIN_INTERVAL_SEC = 10;
 const DEFAULT_LOAD = 1;
+const SUFFIX_PERIODIC = "_PERIODIC";
 
 class Config {
   #logger;
@@ -42,7 +43,7 @@ class Config {
     this.#runInterval = null;
     this.#redisEnabled = null;
     this.#initialized = false;
-    this.#instanceLoadLimit = null;
+    this.#instanceLoadLimit = 100;
     this.#tableNameEventQueue = null;
     this.#tableNameEventLock = null;
     this.#isRunnerDeactivated = false;
@@ -115,7 +116,6 @@ class Config {
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
       event.load = event.load ?? DEFAULT_LOAD;
-      const SUFFIX_PERIODIC = "_PERIODIC";
       event.type = `${event.type}${SUFFIX_PERIODIC}`;
       event.isPeriodic = true;
       this.validatePeriodicConfig(result, event);

package/src/initialize.js

@@ -29,7 +29,6 @@ const CONFIG_VARS = [
   ["processEventsAfterPublish", true],
   ["isRunnerDeactivated", false],
   ["runInterval", 5 * 60 * 1000],
-  ["instanceLoadLimit", 20],
   ["tableNameEventQueue", BASE_TABLES.EVENT],
   ["tableNameEventLock", BASE_TABLES.LOCK],
   ["disableRedis", false],
@@ -43,7 +42,6 @@ const initialize = async ({
   processEventsAfterPublish,
   isRunnerDeactivated,
   runInterval,
-  instanceLoadLimit,
   tableNameEventQueue,
   tableNameEventLock,
   disableRedis,
@@ -52,7 +50,7 @@ const initialize = async ({
 } = {}) => {
   // TODO: initialize check:
   // - content of yaml check
-  // - betweenRuns and instanceLoadLimit
+  // - betweenRuns
 
   if (config.initialized) {
     return;
@@ -65,7 +63,6 @@ const initialize = async ({
     processEventsAfterPublish,
     isRunnerDeactivated,
     runInterval,
-    instanceLoadLimit,
     tableNameEventQueue,
     tableNameEventLock,
     disableRedis,
@@ -92,7 +89,6 @@ const initialize = async ({
     multiTenancyEnabled: config.isMultiTenancy,
     redisEnabled: config.redisEnabled,
     runInterval: config.runInterval,
-    config: config.instanceLoadLimit,
   });
 };
 

package/src/processEventQueue.js

@@ -166,7 +166,7 @@ const processPeriodicEvent = async (eventTypeInstance) => {
             throw new TriggerRollback();
           }
           if (
-            eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
+            eventTypeInstance.transactionMode === TransactionMode.alwaysRollback ||
             eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
           ) {
             throw new TriggerRollback();

package/src/redisPubSub.js

@@ -4,6 +4,7 @@ const redis = require("./shared/redis");
 const { checkLockExistsAndReturnValue } = require("./shared/distributedLock");
 const config = require("./config");
 const { runEventCombinationForTenant } = require("./runner");
+const { getSubdomainForTenantId } = require("./shared/cdsHelper");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "eventQueue/redisPubSub";
@@ -26,7 +27,15 @@ const messageHandlerProcessEvents = async (messageData) => {
       type,
       subType,
     });
-    await runEventCombinationForTenant(tenantId, type, subType);
+    const subdomain = await getSubdomainForTenantId(tenantId);
+    const tenantContext = {
+      tenant: tenantId,
+      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+    };
+    return await cds.tx(tenantContext, async ({ context }) => {
+      return await runEventCombinationForTenant(context, type, subType);
+    });
   } catch (err) {
     logger.error("could not parse event information", {
       messageData,
@@ -36,13 +45,25 @@ const messageHandlerProcessEvents = async (messageData) => {
 
 const broadcastEvent = async (tenantId, type, subType) => {
   const logger = cds.log(COMPONENT_NAME);
-  if (!config.redisEnabled) {
-    if (config.registerAsEventProcessor) {
-      await runEventCombinationForTenant(tenantId, type, subType);
-    }
-    return;
-  }
   try {
+    if (!config.redisEnabled) {
+      if (config.registerAsEventProcessor) {
+        let context = {};
+        if (tenantId) {
+          const subdomain = await getSubdomainForTenantId(tenantId);
+          context = {
+            // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+            tenant: tenantId,
+            http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+          };
+        }
+
+        return await cds.tx(context, async ({ context }) => {
+          return await runEventCombinationForTenant(context, type, subType);
+        });
+      }
+      return;
+    }
     const result = await checkLockExistsAndReturnValue(
       new cds.EventContext({ tenant: tenantId }),
       [type, subType].join("##")

package/src/runner.js

@@ -94,45 +94,61 @@ const _checkAndTriggerPeriodicEventUpdate = (tenantIds) => {
 
 const _executeEventsAllTenants = (tenantIds, runId) => {
   const events = eventQueueConfig.allEvents;
-  const promises = [];
-  tenantIds.forEach((tenantId) => {
+  const product = tenantIds.reduce((result, tenantId) => {
     events.forEach((event) => {
-      promises.push(
-        WorkerQueue.instance.addToQueue(event.load, async () => {
-          try {
-            const lockId = `${runId}_${event.type}_${event.subType}`;
-            const tenantContext = new cds.EventContext({ tenant: tenantId });
-            const couldAcquireLock = await distributedLock.acquireLock(tenantContext, lockId, {
-              expiryTime: eventQueueConfig.runInterval * 0.95,
-            });
-            if (!couldAcquireLock) {
-              return;
-            }
-            await runEventCombinationForTenant(tenantId, event.type, event.subType, true);
-          } catch (err) {
-            cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-              tenantId,
-            });
+      result.push([tenantId, event]);
+    });
+    return result;
+  }, []);
+
+  return product.map(async ([tenantId, event]) => {
+    const subdomain = await getSubdomainForTenantId(tenantId);
+    const tenantContext = {
+      tenant: tenantId,
+      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+    };
+    return await cds.tx(tenantContext, async ({ context }) => {
+      return await WorkerQueue.instance.addToQueue(event.load, async () => {
+        try {
+          const lockId = `${runId}_${event.type}_${event.subType}`;
+          const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
+            expiryTime: eventQueueConfig.runInterval * 0.95,
+          });
+          if (!couldAcquireLock) {
+            return;
           }
-        })
-      );
+          await runEventCombinationForTenant(context, event.type, event.subType, true);
+        } catch (err) {
+          cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+            tenantId,
+          });
+        }
+      });
     });
   });
-  return promises;
 };
 
 const _executePeriodicEventsAllTenants = (tenantIds, runId) => {
   tenantIds.forEach((tenantId) => {
     WorkerQueue.instance.addToQueue(1, async () => {
       try {
-        const tenantContext = new cds.EventContext({ tenant: tenantId });
-        const couldAcquireLock = await distributedLock.acquireLock(tenantContext, runId, {
-          expiryTime: eventQueueConfig.runInterval * 0.95,
+        const subdomain = await getSubdomainForTenantId(tenantId);
+        const tenantContext = {
+          tenant: tenantId,
+          // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+          http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+        };
+
+        return await cds.tx(tenantContext, async ({ context }) => {
+          const couldAcquireLock = await distributedLock.acquireLock(context, runId, {
+            expiryTime: eventQueueConfig.runInterval * 0.95,
+          });
+          if (!couldAcquireLock) {
+            return;
+          }
+          await _checkPeriodicEventsSingleTenant(context);
         });
-        if (!couldAcquireLock) {
-          return;
-        }
-        await _checkPeriodicEventsSingleTenant(tenantId);
       } catch (err) {
         cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
           tenantId,
@@ -147,7 +163,8 @@ const _singleTenantDb = async (tenantId) => {
   events.forEach((event) => {
     WorkerQueue.instance.addToQueue(event.load, async () => {
       try {
-        await runEventCombinationForTenant(tenantId, event.type, event.subType, true);
+        const context = new cds.EventContext({ tenant: tenantId });
+        await runEventCombinationForTenant(context, event.type, event.subType, true);
       } catch (err) {
         cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
           tenantId,
@@ -215,15 +232,8 @@ const _calculateOffsetForFirstRun = async () => {
   return offsetDependingOnLastRun;
 };
 
-const runEventCombinationForTenant = async (tenantId, type, subType, skipWorkerPool) => {
+const runEventCombinationForTenant = async (context, type, subType, skipWorkerPool) => {
   try {
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const context = new cds.EventContext({
-      tenant: tenantId,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-    });
-    cds.context = context;
     if (skipWorkerPool) {
       return await processEventQueue(context, type, subType);
     } else {
@@ -236,7 +246,7 @@ const runEventCombinationForTenant = async (tenantId, type, subType, skipWorkerP
   } catch (err) {
     const logger = cds.log(COMPONENT_NAME);
     logger.error("error executing event combination for tenant", err, {
-      tenantId,
+      tenantId: context.tenant,
       type,
       subType,
     });
@@ -266,7 +276,7 @@ const _multiTenancyPeriodicEvents = async () => {
   }
 };
 
-const _checkPeriodicEventsSingleTenant = async (tenantId) => {
+const _checkPeriodicEventsSingleTenant = async (context = {}) => {
   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", {
@@ -276,23 +286,16 @@ const _checkPeriodicEventsSingleTenant = async (tenantId) => {
     return;
   }
   try {
-    const subdomain = await cdsHelper.getSubdomainForTenantId(tenantId);
-    const context = new cds.EventContext({
-      tenant: tenantId,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-    });
-    cds.context = context;
     logger.info("executing updating periotic events", {
-      tenantId,
-      subdomain,
+      tenantId: context.tenant,
+      subdomain: context.http?.req.authInfo.getSubdomain(),
     });
     await cdsHelper.executeInNewTransaction(context, "update-periodic-events", async (tx) => {
       await periodicEvents.checkAndInsertPeriodicEvents(tx.context);
     });
   } catch (err) {
     logger.error("Couldn't update periodic events for tenant! Next try after defined interval.", err, {
-      tenantId,
+      tenantId: context.tenant,
       redisEnabled: eventQueueConfig.redisEnabled,
     });
   }

package/src/shared/WorkerQueue.js

@@ -8,9 +8,9 @@ const EventQueueError = require("../EventQueueError");
 const COMPONENT_NAME = "eventQueue/WorkerQueue";
 const NANO_TO_MS = 1e6;
 const THRESHOLD = {
-  INFO: 5 * 1000,
-  WARN: 10 * 1000,
-  ERROR: 15 * 1000,
+  INFO: 15 * 1000,
+  WARN: 30 * 1000,
+  ERROR: 45 * 1000,
 };
 
 class WorkerQueue {