@cap-js-community/event-queue 0.2.2 → 0.2.4

package/src/processEventQueue.js

@@ -4,32 +4,22 @@ const pathLib = require("path");
 
 const cds = require("@sap/cds");
 
-const { getConfigInstance } = require("./config");
+const config = require("./config");
 const { TransactionMode } = require("./constants");
-const { limiter, Funnel } = require("./shared/common");
+const { limiter } = require("./shared/common");
 
 const { executeInNewTransaction, TriggerRollback } = require("./shared/cdsHelper");
 
 const COMPONENT_NAME = "eventQueue/processEventQueue";
 const MAX_EXECUTION_TIME = 5 * 60 * 1000;
 
-const eventQueueRunner = async (context, events) => {
-  const startTime = new Date();
-  const funnel = new Funnel();
-  await Promise.allSettled(
-    events.map((event) =>
-      funnel.run(event.load, async () => processEventQueue(context, event.type, event.subType, startTime))
-    )
-  );
-};
-
 const processEventQueue = async (context, eventType, eventSubType, startTime = new Date()) => {
   let iterationCounter = 0;
   let shouldContinue = true;
   let baseInstance;
   try {
     let eventTypeInstance;
-    const eventConfig = getConfigInstance().getEventConfig(eventType, eventSubType);
+    const eventConfig = config.getEventConfig(eventType, eventSubType);
     const [err, EventTypeClass] = resilientRequire(eventConfig?.impl);
     if (!eventConfig || err || !(typeof EventTypeClass.constructor === "function")) {
       cds.log(COMPONENT_NAME).error("No Implementation found in the provided configuration file.", {
@@ -111,7 +101,7 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
       }
     }
   } catch (err) {
-    cds.log(COMPONENT_NAME).error("Processing event queue failed with unexpected error. Error:", err, {
+    cds.log(COMPONENT_NAME).error("Processing event queue failed with unexpected error.", err, {
       eventType,
       eventSubType,
     });
@@ -137,58 +127,67 @@ const reevaluateShouldContinue = (eventTypeInstance, iterationCounter, startTime
 // TODO: don't forget to release lock
 const processPeriodicEvent = async (eventTypeInstance) => {
   let queueEntry;
+  let processNext = true;
+
   try {
-    await executeInNewTransaction(
-      eventTypeInstance.context,
-      `eventQueue-periodic-scheduleNext-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
-      async (tx) => {
-        eventTypeInstance.processEventContext = tx.context;
-        const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
-        if (!queueEntries.length) {
-          return;
-        }
-        if (queueEntries.length > 1) {
-          queueEntry = await eventTypeInstance.handleDuplicatedPeriodicEventEntry(queueEntries);
-        } else {
-          queueEntry = queueEntries[0];
+    while (processNext) {
+      await executeInNewTransaction(
+        eventTypeInstance.context,
+        `eventQueue-periodic-scheduleNext-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+        async (tx) => {
+          eventTypeInstance.processEventContext = tx.context;
+          const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
+          if (!queueEntries.length) {
+            return;
+          }
+          if (queueEntries.length > 1) {
+            queueEntry = await eventTypeInstance.handleDuplicatedPeriodicEventEntry(queueEntries);
+          } else {
+            queueEntry = queueEntries[0];
+          }
+          processNext = await eventTypeInstance.scheduleNextPeriodEvent(queueEntry);
         }
-        await eventTypeInstance.scheduleNextPeriodEvent(queueEntry);
-      }
-    );
+      );
 
-    if (!queueEntry) {
-      return;
-    }
+      if (!queueEntry) {
+        return;
+      }
 
-    await executeInNewTransaction(
-      eventTypeInstance.context,
-      `eventQueue-periodic-process-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
-      async (tx) => {
-        eventTypeInstance.processEventContext = tx.context;
-        eventTypeInstance.setTxForEventProcessing(queueEntry.ID, cds.tx(tx.context));
-        try {
-          await eventTypeInstance.processEvent(tx.context, queueEntry.ID, [queueEntry]);
-        } catch (err) {
-          eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
-          throw new TriggerRollback();
-        }
-        if (
-          eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
-          eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
-        ) {
-          throw new TriggerRollback();
+      await executeInNewTransaction(
+        eventTypeInstance.context,
+        `eventQueue-periodic-process-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+        async (tx) => {
+          eventTypeInstance.processEventContext = tx.context;
+          eventTypeInstance.setTxForEventProcessing(queueEntry.ID, cds.tx(tx.context));
+          try {
+            await eventTypeInstance.processPeriodicEvent(tx.context, queueEntry.ID, queueEntry);
+          } catch (err) {
+            eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
+            throw new TriggerRollback();
+          }
+          if (
+            eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
+            eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
+          ) {
+            throw new TriggerRollback();
+          }
         }
-      }
-    );
+      );
 
-    await executeInNewTransaction(
-      eventTypeInstance.context,
-      `eventQueue-periodic-setStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
-      async (tx) => {
-        eventTypeInstance.processEventContext = tx.context;
-        await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID);
-      }
-    );
+      await executeInNewTransaction(
+        eventTypeInstance.context,
+        `eventQueue-periodic-setStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+        async (tx) => {
+          eventTypeInstance.processEventContext = tx.context;
+          await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID);
+        }
+      );
+    }
+  } catch (err) {
+    cds.log(COMPONENT_NAME).error("Processing periodic events failed with unexpected error.", err, {
+      eventType: eventTypeInstance?.eventType,
+      eventSubType: eventTypeInstance?.eventSubType,
+    });
   } finally {
     await eventTypeInstance?.handleReleaseLock();
   }
@@ -269,5 +268,4 @@ const resilientRequire = (path) => {
 
 module.exports = {
   processEventQueue,
-  eventQueueRunner,
 };

package/src/publishEvent.js

@@ -28,13 +28,12 @@ const EventQueueError = require("./EventQueueError");
  * @returns {Promise} Returns a promise which resolves to the result of the database insert operation.
  */
 const publishEvent = async (tx, events, skipBroadcast = false) => {
-  const configInstance = config.getConfigInstance();
-  if (!configInstance.initialized) {
+  if (!config.initialized) {
     throw EventQueueError.notInitialized();
   }
   const eventsForProcessing = Array.isArray(events) ? events : [events];
   for (const { type, subType, startAfter } of eventsForProcessing) {
-    const eventConfig = configInstance.getEventConfig(type, subType);
+    const eventConfig = config.getEventConfig(type, subType);
     if (!eventConfig) {
       throw EventQueueError.unknownEventType(type, subType);
     }
@@ -47,7 +46,7 @@ const publishEvent = async (tx, events, skipBroadcast = false) => {
     }
   }
   tx._skipEventQueueBroadcase = skipBroadcast;
-  const result = await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(eventsForProcessing));
+  const result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(eventsForProcessing));
   tx._skipEventQueueBroadcase = false;
   return result;
 };

package/src/redisPubSub.js

@@ -11,7 +11,7 @@ const COMPONENT_NAME = "eventQueue/redisPubSub";
 let subscriberClientPromise;
 
 const initEventQueueRedisSubscribe = () => {
-  if (subscriberClientPromise || !config.getConfigInstance().redisEnabled) {
+  if (subscriberClientPromise || !config.redisEnabled) {
     return;
   }
   redis.subscribeRedisChannel(EVENT_MESSAGE_CHANNEL, messageHandlerProcessEvents);
@@ -36,9 +36,8 @@ const messageHandlerProcessEvents = async (messageData) => {
 
 const broadcastEvent = async (tenantId, type, subType) => {
   const logger = cds.log(COMPONENT_NAME);
-  const configInstance = config.getConfigInstance();
-  if (!configInstance.redisEnabled) {
-    if (configInstance.registerAsEventProcessor) {
+  if (!config.redisEnabled) {
+    if (config.registerAsEventProcessor) {
       await runEventCombinationForTenant(tenantId, type, subType);
     }
     return;
@@ -49,7 +48,10 @@ const broadcastEvent = async (tenantId, type, subType) => {
       [type, subType].join("##")
     );
     if (result) {
-      logger.info("skip publish redis event as no lock is available");
+      logger.info("skip publish redis event as no lock is available", {
+        type,
+        subType,
+      });
       return;
     }
     logger.debug("publishing redis event", {
@@ -59,7 +61,7 @@ const broadcastEvent = async (tenantId, type, subType) => {
     });
     await redis.publishMessage(EVENT_MESSAGE_CHANNEL, JSON.stringify({ tenantId, type, subType }));
   } catch (err) {
-    logger.error(`publish event failed with error: ${err.toString()}`, {
+    logger.error("publish event failed!", err, {
       tenantId,
       type,
       subType,

package/src/runner.js

@@ -3,8 +3,8 @@
 const { randomUUID } = require("crypto");
 
 const eventQueueConfig = require("./config");
-const { eventQueueRunner, processEventQueue } = require("./processEventQueue");
-const { getWorkerPoolInstance } = require("./shared/WorkerQueue");
+const { processEventQueue } = require("./processEventQueue");
+const WorkerQueue = require("./shared/WorkerQueue");
 const cdsHelper = require("./shared/cdsHelper");
 const distributedLock = require("./shared/distributedLock");
 const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
@@ -19,8 +19,9 @@ const EVENT_QUEUE_RUN_PERIODIC_EVENT = "EVENT_QUEUE_RUN_PERIODIC_EVENT";
 const OFFSET_FIRST_RUN = 10 * 1000;
 
 let tenantIdHash;
+let singleRunDone;
 
-const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenant, _executeRunForTenant);
+const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenant, _singleTenantDb);
 
 const multiTenancyDb = () => _scheduleFunction(_multiTenancyPeriodicEvents, _multiTenancyDb);
 
@@ -28,8 +29,7 @@ const multiTenancyRedis = () => _scheduleFunction(_multiTenancyPeriodicEvents, _
 
 const _scheduleFunction = async (singleRunFn, periodicFn) => {
   const logger = cds.log(COMPONENT_NAME);
-  const configInstance = eventQueueConfig.getConfigInstance();
-  const eventsForAutomaticRun = configInstance.allEvents;
+  const eventsForAutomaticRun = eventQueueConfig.allEvents;
   if (!eventsForAutomaticRun.length) {
     logger.warn("no events for automatic run are configured - skipping runner registration");
     return;
@@ -37,10 +37,14 @@ const _scheduleFunction = async (singleRunFn, periodicFn) => {
 
   const fnWithRunningCheck = () => {
     const logger = cds.log(COMPONENT_NAME);
-    if (configInstance.isRunnerDeactivated) {
+    if (eventQueueConfig.isRunnerDeactivated) {
       logger.info("runner is deactivated via config variable. Skipping this run.");
       return;
     }
+    if (!singleRunDone) {
+      singleRunDone = true;
+      singleRunFn().catch(() => (singleRunDone = false));
+    }
     return periodicFn();
   };
 
@@ -51,9 +55,8 @@ const _scheduleFunction = async (singleRunFn, periodicFn) => {
   });
 
   setTimeout(() => {
-    singleRunFn();
     fnWithRunningCheck();
-    const intervalRunner = new SetIntervalDriftSafe(configInstance.runInterval);
+    const intervalRunner = new SetIntervalDriftSafe(eventQueueConfig.runInterval);
     intervalRunner.run(fnWithRunningCheck);
   }, offsetDependingOnLastRun).unref();
 };
@@ -63,7 +66,7 @@ const _multiTenancyRedis = async () => {
   const emptyContext = new cds.EventContext({});
   logger.info("executing event queue run for multi instance and tenant");
   const tenantIds = await cdsHelper.getAllTenantIds();
-  _checkAndTriggerPriodicEventUpdate(tenantIds);
+  _checkAndTriggerPeriodicEventUpdate(tenantIds);
 
   const runId = await _acquireRunId(emptyContext);
 
@@ -72,10 +75,10 @@ const _multiTenancyRedis = async () => {
     return;
   }
 
-  _executeAllTenants(tenantIds, runId);
+  return _executeEventsAllTenants(tenantIds, runId);
 };
 
-const _checkAndTriggerPriodicEventUpdate = (tenantIds) => {
+const _checkAndTriggerPeriodicEventUpdate = (tenantIds) => {
   const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
@@ -84,25 +87,52 @@ const _checkAndTriggerPriodicEventUpdate = (tenantIds) => {
   if (tenantIdHash && tenantIdHash !== hash) {
     cds.log(COMPONENT_NAME).info("tenant id hash changed, triggering updating periodic events!");
     _multiTenancyPeriodicEvents().catch((err) => {
-      cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events! Error:", err);
+      cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events!", err);
     });
   }
 };
 
-const _executeAllTenantsGeneric = (tenantIds, runId, fn) => {
-  const configInstance = eventQueueConfig.getConfigInstance();
-  const workerQueueInstance = getWorkerPoolInstance();
+const _executeEventsAllTenants = (tenantIds, runId) => {
+  const events = eventQueueConfig.allEvents;
+  const promises = [];
   tenantIds.forEach((tenantId) => {
-    workerQueueInstance.addToQueue(async () => {
+    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,
+            });
+          }
+        })
+      );
+    });
+  });
+  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: configInstance.runInterval * 0.95,
+          expiryTime: eventQueueConfig.runInterval * 0.95,
         });
         if (!couldAcquireLock) {
           return;
         }
-        await fn(tenantId, runId);
+        await _checkPeriodicEventsSingleTenant(tenantId);
       } catch (err) {
         cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
           tenantId,
@@ -112,49 +142,33 @@ const _executeAllTenantsGeneric = (tenantIds, runId, fn) => {
   });
 };
 
-const _executeAllTenants = (tenantIds, runId) => _executeAllTenantsGeneric(tenantIds, runId, _executeRunForTenant);
-
-const _executePeriodicEventsAllTenants = (tenantIds, runId) =>
-  _executeAllTenantsGeneric(tenantIds, runId, _checkPeriodicEventsSingleTenant);
-
-const _executeRunForTenant = async (tenantId, runId) => {
-  const logger = cds.log(COMPONENT_NAME);
-  const configInstance = eventQueueConfig.getConfigInstance();
-  try {
-    const eventsForAutomaticRun = configInstance.allEvents;
-    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 eventQueue run", {
-      tenantId,
-      subdomain,
-      ...(runId ? { runId } : null),
-    });
-    await eventQueueRunner(context, eventsForAutomaticRun);
-  } catch (err) {
-    logger.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
-      tenantId,
-      redisEnabled: configInstance.redisEnabled,
+const _singleTenantDb = async (tenantId) => {
+  const events = eventQueueConfig.allEvents;
+  events.forEach((event) => {
+    WorkerQueue.instance.addToQueue(event.load, async () => {
+      try {
+        await runEventCombinationForTenant(tenantId, event.type, event.subType, true);
+      } catch (err) {
+        cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+          tenantId,
+          redisEnabled: eventQueueConfig.redisEnabled,
+        });
+      }
     });
-  }
+  });
 };
 
 const _acquireRunId = async (context) => {
-  const configInstance = eventQueueConfig.getConfigInstance();
   let runId = randomUUID();
   const couldSetValue = await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_ID, runId, {
     tenantScoped: false,
-    expiryTime: configInstance.runInterval * 0.95,
+    expiryTime: eventQueueConfig.runInterval * 0.95,
   });
 
   if (couldSetValue) {
     await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_TS, new Date().toISOString(), {
       tenantScoped: false,
-      expiryTime: configInstance.runInterval,
+      expiryTime: eventQueueConfig.runInterval,
       overrideValue: true,
     });
   } else {
@@ -167,13 +181,12 @@ const _acquireRunId = async (context) => {
 };
 
 const _calculateOffsetForFirstRun = async () => {
-  const configInstance = eventQueueConfig.getConfigInstance();
   let offsetDependingOnLastRun = OFFSET_FIRST_RUN;
   const now = Date.now();
   // NOTE: this is only supported with Redis, because this is a tenant agnostic information
   //       currently there is no proper place to store this information beside t0 schema
   try {
-    if (configInstance.redisEnabled) {
+    if (eventQueueConfig.redisEnabled) {
       const dummyContext = new cds.EventContext({});
       let lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
         tenantScoped: false,
@@ -182,7 +195,7 @@ const _calculateOffsetForFirstRun = async () => {
         const ts = new Date(now).toISOString();
         const couldSetValue = await distributedLock.setValueWithExpire(dummyContext, EVENT_QUEUE_RUN_TS, ts, {
           tenantScoped: false,
-          expiryTime: configInstance.runInterval,
+          expiryTime: eventQueueConfig.runInterval,
         });
         if (couldSetValue) {
           lastRunTs = ts;
@@ -192,20 +205,17 @@ const _calculateOffsetForFirstRun = async () => {
           });
         }
       }
-      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + configInstance.runInterval - now;
+      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + eventQueueConfig.runInterval - now;
     }
   } catch (err) {
     cds
       .log(COMPONENT_NAME)
-      .error(
-        "calculating offset for first run failed, falling back to default. Runs might be out-of-sync. Error:",
-        err
-      );
+      .error("calculating offset for first run failed, falling back to default. Runs might be out-of-sync.", err);
   }
   return offsetDependingOnLastRun;
 };
 
-const runEventCombinationForTenant = async (tenantId, type, subType) => {
+const runEventCombinationForTenant = async (tenantId, type, subType, skipWorkerPool) => {
   try {
     const subdomain = await getSubdomainForTenantId(tenantId);
     const context = new cds.EventContext({
@@ -214,7 +224,15 @@ const runEventCombinationForTenant = async (tenantId, type, subType) => {
       http: { req: { authInfo: { getSubdomain: () => subdomain } } },
     });
     cds.context = context;
-    getWorkerPoolInstance().addToQueue(async () => await processEventQueue(context, type, subType));
+    if (skipWorkerPool) {
+      return await processEventQueue(context, type, subType);
+    } else {
+      const config = eventQueueConfig.getEventConfig(type, subType);
+      return await WorkerQueue.instance.addToQueue(
+        config.load,
+        async () => await processEventQueue(context, type, subType)
+      );
+    }
   } catch (err) {
     const logger = cds.log(COMPONENT_NAME);
     logger.error("error executing event combination for tenant", err, {
@@ -230,12 +248,10 @@ const _multiTenancyDb = async () => {
   try {
     logger.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
-    _checkAndTriggerPriodicEventUpdate(tenantIds);
-    _executeAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
+    _checkAndTriggerPeriodicEventUpdate(tenantIds);
+    return _executeEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
   } catch (err) {
-    logger.error(
-      `Couldn't fetch tenant ids for event queue processing! Next try after defined interval. Error: ${err}`
-    );
+    logger.error("Couldn't fetch tenant ids for event queue processing! Next try after defined interval.", err);
   }
 };
 
@@ -246,15 +262,18 @@ const _multiTenancyPeriodicEvents = async () => {
     const tenantIds = await cdsHelper.getAllTenantIds();
     _executePeriodicEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_PERIODIC_EVENT);
   } catch (err) {
-    logger.error(`Couldn't fetch tenant ids for updating periodic event processing! Error: ${err}`);
+    logger.error("Couldn't fetch tenant ids for updating periodic event processing!", err);
   }
 };
 
 const _checkPeriodicEventsSingleTenant = async (tenantId) => {
   const logger = cds.log(COMPONENT_NAME);
-  const configInstance = eventQueueConfig.getConfigInstance();
-  if (!configInstance.updatePeriodicEvents) {
-    logger.info("updating of periodic events is disabled");
+  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;
   }
   try {
     const subdomain = await cdsHelper.getSubdomainForTenantId(tenantId);
@@ -272,9 +291,9 @@ const _checkPeriodicEventsSingleTenant = async (tenantId) => {
       await periodicEvents.checkAndInsertPeriodicEvents(tx.context);
     });
   } catch (err) {
-    logger.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
+    logger.error("Couldn't update periodic events for tenant! Next try after defined interval.", err, {
       tenantId,
-      redisEnabled: configInstance.redisEnabled,
+      redisEnabled: eventQueueConfig.redisEnabled,
     });
   }
 };