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

package/package.json

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

@@ -8,7 +8,7 @@ const distributedLock = require("./shared/distributedLock");
 const EventQueueError = require("./EventQueueError");
 const { arrayToFlatMap } = require("./shared/common");
 const eventScheduler = require("./shared/eventScheduler");
-const eventQueueConfig = require("./config");
+const eventConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
 
 const IMPLEMENT_ERROR_MESSAGE = "needs to be reimplemented";
@@ -31,37 +31,43 @@ class EventQueueProcessorBase {
   #eventType = null;
   #eventSubType = null;
   #config = null;
+  #eventSchedulerInstance = null;
+  #eventConfig;
+  #isPeriodic;
 
   constructor(context, eventType, eventSubType, config) {
     this.__context = context;
     this.__baseContext = context;
     this.__tx = cds.tx(context);
     this.__baseLogger = cds.log(COMPONENT_NAME);
+    this.#eventSchedulerInstance = eventScheduler.getInstance();
+    this.#config = eventConfig;
+    this.#isPeriodic = this.#config.isPeriodicEvent(eventType, eventSubType);
     this.__logger = null;
     this.__eventProcessingMap = {};
     this.__statusMap = {};
     this.__commitedStatusMap = {};
     this.#eventType = eventType;
     this.#eventSubType = eventSubType;
-    this.__eventConfig = config ?? {};
-    this.__parallelEventProcessing = this.__eventConfig.parallelEventProcessing ?? DEFAULT_PARALLEL_EVENT_PROCESSING;
+    this.#eventConfig = config ?? {};
+    this.__parallelEventProcessing = this.#eventConfig.parallelEventProcessing ?? DEFAULT_PARALLEL_EVENT_PROCESSING;
     if (this.__parallelEventProcessing > LIMIT_PARALLEL_EVENT_PROCESSING) {
       this.__parallelEventProcessing = LIMIT_PARALLEL_EVENT_PROCESSING;
     }
     // NOTE: keep the feature, this might be needed again
     this.__concurrentEventProcessing = false;
-    this.__startTime = this.__eventConfig.startTime ?? new Date();
-    this.__retryAttempts = this.__eventConfig.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS;
-    this.__selectMaxChunkSize = this.__eventConfig.selectMaxChunkSize ?? SELECT_LIMIT_EVENTS_PER_TICK;
-    this.__selectNextChunk = !!this.__eventConfig.checkForNextChunk;
+    this.__startTime = this.#eventConfig.startTime ?? new Date();
+    this.__retryAttempts = this.#eventConfig.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS;
+    this.__selectMaxChunkSize = this.#eventConfig.selectMaxChunkSize ?? SELECT_LIMIT_EVENTS_PER_TICK;
+    this.__selectNextChunk = !!this.#eventConfig.checkForNextChunk;
     this.__keepalivePromises = {};
-    this.__outdatedCheckEnabled = this.__eventConfig.eventOutdatedCheck ?? true;
-    this.__transactionMode = this.__eventConfig.transactionMode ?? TransactionMode.isolated;
-    if (this.__eventConfig.deleteFinishedEventsAfterDays) {
+    this.__outdatedCheckEnabled = this.#eventConfig.eventOutdatedCheck ?? true;
+    this.__transactionMode = this.#eventConfig.transactionMode ?? TransactionMode.isolated;
+    if (this.#eventConfig.deleteFinishedEventsAfterDays) {
       this.__deleteFinishedEventsAfter =
-        Number.isInteger(this.__eventConfig.deleteFinishedEventsAfterDays) &&
-        this.__eventConfig.deleteFinishedEventsAfterDays > 0
-          ? this.__eventConfig.deleteFinishedEventsAfterDays
+        Number.isInteger(this.#eventConfig.deleteFinishedEventsAfterDays) &&
+        this.#eventConfig.deleteFinishedEventsAfterDays > 0
+          ? this.#eventConfig.deleteFinishedEventsAfterDays
           : DEFAULT_DELETE_FINISHED_EVENTS_AFTER;
     } else {
       this.__deleteFinishedEventsAfter = DEFAULT_DELETE_FINISHED_EVENTS_AFTER;
@@ -71,7 +77,6 @@ class EventQueueProcessorBase {
     this.__txUsageAllowed = true;
     this.__txMap = {};
     this.__txRollback = {};
-    this.#config = eventQueueConfig.getConfigInstance();
     this.__queueEntries = [];
   }
 
@@ -610,9 +615,8 @@ class EventQueueProcessorBase {
   }
 
   #handleDelayedEvents(delayedEvents) {
-    const eventSchedulerInstance = eventScheduler.getInstance();
     for (const delayedEvent of delayedEvents) {
-      eventSchedulerInstance.scheduleEvent(
+      this.#eventSchedulerInstance.scheduleEvent(
         this.__context.tenant,
         this.#eventType,
         this.#eventSubType,
@@ -836,17 +840,47 @@ class EventQueueProcessorBase {
   }
 
   async scheduleNextPeriodEvent(queueEntry) {
-    const interval = this.__eventConfig.interval;
+    const interval = this.#eventConfig.interval;
     const newEvent = {
       type: this.#eventType,
       subType: this.#eventSubType,
       startAfter: new Date(new Date(queueEntry.startAfter).getTime() + interval * 1000),
     };
+    const { relative } = this.#eventSchedulerInstance.calculateOffset(
+      this.#eventType,
+      this.#eventSubType,
+      newEvent.startAfter
+    );
+
+    // more than one interval behind - shift tick to keep up
+    if (relative < 0 && Math.abs(relative) >= this.#eventConfig.interval * 1000) {
+      newEvent.startAfter = new Date(Date.now() + 5 * 1000);
+      this.logger.info("interval adjusted because shifted more than one interval", {
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+        newStartAfter: newEvent.startAfter,
+      });
+    }
+
     this.tx._skipEventQueueBroadcase = true;
     await this.tx.run(INSERT.into(this.#config.tableNameEventQueue).entries({ ...newEvent }));
     this.tx._skipEventQueueBroadcase = false;
     if (interval < this.#config.runInterval) {
       this.#handleDelayedEvents([newEvent]);
+      const { relative: relativeAfterSchedule } = this.#eventSchedulerInstance.calculateOffset(
+        this.#eventType,
+        this.#eventSubType,
+        newEvent.startAfter
+      );
+      // next tick is already behind schedule --> execute direct
+      if (relativeAfterSchedule <= 0) {
+        this.logger.info("running behind schedule - executing next tick immediately", {
+          eventType: this.#eventType,
+          eventSubType: this.#eventSubType,
+          newStartAfter: newEvent.startAfter,
+        });
+        return true;
+      }
     }
   }
 
@@ -986,7 +1020,7 @@ class EventQueueProcessorBase {
   }
 
   get isPeriodicEvent() {
-    return this.__eventConfig.isPeriodic;
+    return this.#eventConfig.isPeriodic;
   }
 }
 

package/src/config.js

@@ -6,8 +6,6 @@ const { getEnvInstance } = require("./shared/env");
 const redis = require("./shared/redis");
 const EventQueueError = require("./EventQueueError");
 
-let instance;
-
 const FOR_UPDATE_TIMEOUT = 10;
 const GLOBAL_TX_TIMEOUT = 30 * 60 * 1000;
 const REDIS_CONFIG_CHANNEL = "EVENT_QUEUE_CONFIG_CHANNEL";
@@ -33,6 +31,7 @@ class Config {
   #env;
   #eventMap;
   #updatePeriodicEvents;
+  static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
     this.#config = null;
@@ -112,15 +111,18 @@ class Config {
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
-      this.validatePeriodicConfig(result, event);
+      const SUFFIX_PERIODIC = "_PERIODIC";
+      event.type = `${event.type}${SUFFIX_PERIODIC}`;
       event.isPeriodic = true;
+      this.validatePeriodicConfig(result, event);
       result[[event.type, event.subType].join("##")] = event;
       return result;
     }, this.#eventMap);
   }
 
   validatePeriodicConfig(eventMap, config) {
-    if (eventMap[this.generateKey(config.type, config.subType)]) {
+    const key = this.generateKey(config.type, config.subType);
+    if (eventMap[key] && eventMap[key].isPeriodic) {
       throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
     }
 
@@ -134,7 +136,8 @@ class Config {
   }
 
   validateAdHocEvents(eventMap, config) {
-    if (eventMap[this.generateKey(config.type, config.subType)]) {
+    const key = this.generateKey(config.type, config.subType);
+    if (eventMap[key] && !eventMap[key].isPeriodic) {
       throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
     }
 
@@ -274,15 +277,18 @@ class Config {
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }
-}
 
-const getConfigInstance = () => {
-  if (!instance) {
-    instance = new Config();
+  /**
+    @return { Config }
+  **/
+  static get instance() {
+    if (!Config.#instance) {
+      Config.#instance = new Config();
+    }
+    return Config.#instance;
   }
-  return instance;
-};
+}
+
+const instance = Config.instance;
 
-module.exports = {
-  getConfigInstance,
-};
+module.exports = instance;

package/src/dbHandler.js

@@ -8,8 +8,7 @@ const config = require("./config");
 const COMPONENT_NAME = "eventQueue/dbHandler";
 
 const registerEventQueueDbHandler = (dbService) => {
-  const configInstance = config.getConfigInstance();
-  const def = dbService.model.definitions[configInstance.tableNameEventQueue];
+  const def = dbService.model.definitions[config.tableNameEventQueue];
   dbService.after("CREATE", def, (_, req) => {
     if (req.tx._skipEventQueueBroadcase) {
       return;
@@ -21,7 +20,7 @@ const registerEventQueueDbHandler = (dbService) => {
     const eventCombinations = Object.keys(
       data.reduce((result, event) => {
         const key = [event.type, event.subType].join("##");
-        if (!configInstance.hasEventAfterCommitFlag(event.type, event.subType) || eventQueuePublishEvents[key]) {
+        if (!config.hasEventAfterCommitFlag(event.type, event.subType) || eventQueuePublishEvents[key]) {
           return result;
         }
         eventQueuePublishEvents[key] = true;

package/src/index.js

@@ -11,7 +11,7 @@
 
 module.exports = {
   ...require("./initialize"),
-  ...require("./config"),
+  config: require("./config"),
   ...require("./processEventQueue"),
   ...require("./dbHandler"),
   ...require("./constants"),

package/src/initialize.js

@@ -11,7 +11,7 @@ const VError = require("verror");
 const EventQueueError = require("./EventQueueError");
 const runner = require("./runner");
 const dbHandler = require("./dbHandler");
-const { getConfigInstance } = require("./config");
+const config = require("./config");
 const { initEventQueueRedisSubscribe, closeSubscribeClient } = require("./redisPubSub");
 const { closeMainClient } = require("./shared/redis");
 
@@ -54,11 +54,10 @@ const initialize = async ({
   // - content of yaml check
   // - betweenRuns and parallelTenantProcessing
 
-  const configInstance = getConfigInstance();
-  if (configInstance.initialized) {
+  if (config.initialized) {
     return;
   }
-  configInstance.initialized = true;
+  config.initialized = true;
 
   mixConfigVarsWithEnv(
     configFilePath,
@@ -75,24 +74,24 @@ const initialize = async ({
   );
 
   const logger = cds.log(COMPONENT);
-  configInstance.fileContent = await readConfigFromFile(configInstance.configFilePath);
-  configInstance.checkRedisEnabled();
+  config.fileContent = await readConfigFromFile(config.configFilePath);
+  config.checkRedisEnabled();
 
   const dbService = await cds.connect.to("db");
   await (cds.model ? Promise.resolve() : new Promise((resolve) => cds.on("serving", resolve)));
-  !configInstance.skipCsnCheck && (await csnCheck());
-  if (configInstance.processEventsAfterPublish) {
+  !config.skipCsnCheck && (await csnCheck());
+  if (config.processEventsAfterPublish) {
     dbHandler.registerEventQueueDbHandler(dbService);
   }
 
   registerEventProcessors();
   registerCdsShutdown();
   logger.info("event queue initialized", {
-    registerAsEventProcessor: configInstance.registerAsEventProcessor,
-    multiTenancyEnabled: configInstance.isMultiTenancy,
-    redisEnabled: configInstance.redisEnabled,
-    runInterval: configInstance.runInterval,
-    parallelTenantProcessing: configInstance.parallelTenantProcessing,
+    registerAsEventProcessor: config.registerAsEventProcessor,
+    multiTenancyEnabled: config.isMultiTenancy,
+    redisEnabled: config.redisEnabled,
+    runInterval: config.runInterval,
+    config: config.parallelTenantProcessing,
   });
 };
 
@@ -114,22 +113,20 @@ const readConfigFromFile = async (configFilepath) => {
 };
 
 const registerEventProcessors = () => {
-  const configInstance = getConfigInstance();
-
-  if (!configInstance.registerAsEventProcessor) {
+  if (!config.registerAsEventProcessor) {
     return;
   }
 
   const errorHandler = (err) => cds.log(COMPONENT).error("error during init runner", err);
 
-  if (!configInstance.isMultiTenancy) {
+  if (!config.isMultiTenancy) {
     runner.singleTenant().catch(errorHandler);
     return;
   }
 
-  if (configInstance.redisEnabled) {
+  if (config.redisEnabled) {
     initEventQueueRedisSubscribe();
-    configInstance.attachConfigChangeHandler();
+    config.attachConfigChangeHandler();
     runner.multiTenancyRedis().catch(errorHandler);
   } else {
     runner.multiTenancyDb().catch(errorHandler);
@@ -137,21 +134,17 @@ const registerEventProcessors = () => {
 };
 
 const csnCheck = async () => {
-  const configInstance = getConfigInstance();
-  const eventCsn = cds.model.definitions[configInstance.tableNameEventQueue];
+  const eventCsn = cds.model.definitions[config.tableNameEventQueue];
   if (!eventCsn) {
-    throw EventQueueError.missingTableInCsn(configInstance.tableNameEventQueue);
+    throw EventQueueError.missingTableInCsn(config.tableNameEventQueue);
   }
 
-  const lockCsn = cds.model.definitions[configInstance.tableNameEventLock];
+  const lockCsn = cds.model.definitions[config.tableNameEventLock];
   if (!lockCsn) {
-    throw EventQueueError.missingTableInCsn(configInstance.tableNameEventLock);
+    throw EventQueueError.missingTableInCsn(config.tableNameEventLock);
   }
 
-  if (
-    configInstance.tableNameEventQueue === BASE_TABLES.EVENT &&
-    configInstance.tableNameEventLock === BASE_TABLES.LOCK
-  ) {
+  if (config.tableNameEventQueue === BASE_TABLES.EVENT && config.tableNameEventLock === BASE_TABLES.LOCK) {
     return; // no need to check base tables
   }
 
@@ -181,10 +174,9 @@ const checkCustomTable = (baseCsn, customCsn) => {
 };
 
 const mixConfigVarsWithEnv = (...args) => {
-  const configInstance = getConfigInstance();
   CONFIG_VARS.forEach(([configName, defaultValue], index) => {
     const configValue = args[index];
-    configInstance[configName] = configValue ?? cds.env.eventQueue?.[configName] ?? defaultValue;
+    config[configName] = configValue ?? cds.env.eventQueue?.[configName] ?? defaultValue;
   });
 };
 

package/src/periodicEvents.js

@@ -4,19 +4,18 @@ const cds = require("@sap/cds");
 
 const { EventProcessingStatus } = require("./constants");
 const { processChunkedSync } = require("./shared/common");
-const { getConfigInstance } = require("./config");
+const eventConfig = require("./config");
 
 const COMPONENT_NAME = "eventQueue/periodicEvents";
 
 const checkAndInsertPeriodicEvents = async (context) => {
   const tx = cds.tx(context);
-  const configInstance = getConfigInstance();
-  const baseCqn = SELECT.from(configInstance.tableNameEventQueue)
+  const baseCqn = SELECT.from(eventConfig.tableNameEventQueue)
     .where([
       { list: [{ ref: ["type"] }, { ref: ["subType"] }] },
       "IN",
       {
-        list: configInstance.periodicEvents.map((periodicEvent) => ({
+        list: eventConfig.periodicEvents.map((periodicEvent) => ({
           list: [{ val: periodicEvent.type }, { val: periodicEvent.subType }],
         })),
       },
@@ -30,7 +29,7 @@ const checkAndInsertPeriodicEvents = async (context) => {
 
   if (!currentPeriodEvents.length) {
     // fresh insert all
-    return await insertPeriodEvents(tx, configInstance.periodicEvents);
+    return await insertPeriodEvents(tx, eventConfig.periodicEvents);
   }
 
   const exitingEventMap = currentPeriodEvents.reduce((result, current) => {
@@ -39,7 +38,7 @@ const checkAndInsertPeriodicEvents = async (context) => {
     return result;
   }, {});
 
-  const { newEvents, existingEvents } = configInstance.periodicEvents.reduce(
+  const { newEvents, existingEvents } = eventConfig.periodicEvents.reduce(
     (result, event) => {
       if (exitingEventMap[_generateKey(event)]) {
         result.existingEvents.push(exitingEventMap[_generateKey(event)]);
@@ -53,7 +52,7 @@ const checkAndInsertPeriodicEvents = async (context) => {
 
   const currentDate = new Date();
   const exitingWithNotMatchingInterval = existingEvents.filter((existingEvent) => {
-    const config = configInstance.getEventConfig(existingEvent.type, existingEvent.subType);
+    const config = eventConfig.getEventConfig(existingEvent.type, existingEvent.subType);
     const eventStartAfter = new Date(existingEvent.startAfter);
     // check if to far in future
     const dueInWithNewInterval = new Date(currentDate.getTime() + config.interval * 1000);
@@ -65,7 +64,7 @@ const checkAndInsertPeriodicEvents = async (context) => {
       changedEvents: exitingWithNotMatchingInterval.map(({ type, subType }) => ({ type, subType })),
     });
   await tx.run(
-    DELETE.from(configInstance.tableNameEventQueue).where(
+    DELETE.from(eventConfig.tableNameEventQueue).where(
       "ID IN",
       exitingWithNotMatchingInterval.map(({ ID }) => ID)
     )
@@ -82,11 +81,10 @@ const checkAndInsertPeriodicEvents = async (context) => {
 
 const insertPeriodEvents = async (tx, events) => {
   const startAfter = new Date();
-  const configInstance = getConfigInstance();
   processChunkedSync(events, 4, (chunk) => {
     cds.log(COMPONENT_NAME).info("inserting changed or new periodic events", {
       events: chunk.map(({ type, subType }) => {
-        const { interval } = configInstance.getEventConfig(type, subType);
+        const { interval } = eventConfig.getEventConfig(type, subType);
         return { type, subType, interval };
       }),
     });
@@ -98,7 +96,7 @@ const insertPeriodEvents = async (tx, events) => {
   }));
 
   tx._skipEventQueueBroadcase = true;
-  await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(periodEventsInsert));
+  await tx.run(INSERT.into(eventConfig.tableNameEventQueue).entries(periodEventsInsert));
   tx._skipEventQueueBroadcase = false;
 };
 

package/src/processEventQueue.js

@@ -4,7 +4,7 @@ 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");
 
@@ -29,7 +29,7 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
   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.", {
@@ -137,58 +137,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.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-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. Error:", err, {
+      eventType: eventTypeInstance?.eventType,
+      eventSubType: eventTypeInstance?.eventSubType,
+    });
   } finally {
     await eventTypeInstance?.handleReleaseLock();
   }

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;

package/src/runner.js

@@ -19,6 +19,7 @@ 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);
 
@@ -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);
 
@@ -75,7 +78,7 @@ const _multiTenancyRedis = async () => {
   _executeAllTenants(tenantIds, runId);
 };
 
-const _checkAndTriggerPriodicEventUpdate = (tenantIds) => {
+const _checkAndTriggerPeriodicEventUpdate = (tenantIds) => {
   const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
@@ -90,14 +93,13 @@ const _checkAndTriggerPriodicEventUpdate = (tenantIds) => {
 };
 
 const _executeAllTenantsGeneric = (tenantIds, runId, fn) => {
-  const configInstance = eventQueueConfig.getConfigInstance();
   const workerQueueInstance = getWorkerPoolInstance();
   tenantIds.forEach((tenantId) => {
     workerQueueInstance.addToQueue(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;
@@ -119,9 +121,8 @@ const _executePeriodicEventsAllTenants = (tenantIds, runId) =>
 
 const _executeRunForTenant = async (tenantId, runId) => {
   const logger = cds.log(COMPONENT_NAME);
-  const configInstance = eventQueueConfig.getConfigInstance();
   try {
-    const eventsForAutomaticRun = configInstance.allEvents;
+    const eventsForAutomaticRun = eventQueueConfig.allEvents;
     const subdomain = await cdsHelper.getSubdomainForTenantId(tenantId);
     const context = new cds.EventContext({
       tenant: tenantId,
@@ -138,23 +139,22 @@ const _executeRunForTenant = async (tenantId, runId) => {
   } catch (err) {
     logger.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
       tenantId,
-      redisEnabled: configInstance.redisEnabled,
+      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 +167,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 +181,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,7 +191,7 @@ const _calculateOffsetForFirstRun = async () => {
           });
         }
       }
-      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + configInstance.runInterval - now;
+      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + eventQueueConfig.runInterval - now;
     }
   } catch (err) {
     cds
@@ -230,7 +229,7 @@ const _multiTenancyDb = async () => {
   try {
     logger.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
-    _checkAndTriggerPriodicEventUpdate(tenantIds);
+    _checkAndTriggerPeriodicEventUpdate(tenantIds);
     _executeAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
   } catch (err) {
     logger.error(
@@ -252,8 +251,7 @@ const _multiTenancyPeriodicEvents = async () => {
 
 const _checkPeriodicEventsSingleTenant = async (tenantId) => {
   const logger = cds.log(COMPONENT_NAME);
-  const configInstance = eventQueueConfig.getConfigInstance();
-  if (!configInstance.updatePeriodicEvents) {
+  if (!eventQueueConfig.updatePeriodicEvents) {
     logger.info("updating of periodic events is disabled");
   }
   try {
@@ -274,7 +272,7 @@ const _checkPeriodicEventsSingleTenant = async (tenantId) => {
   } catch (err) {
     logger.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
       tenantId,
-      redisEnabled: configInstance.redisEnabled,
+      redisEnabled: eventQueueConfig.redisEnabled,
     });
   }
 };

package/src/shared/WorkerQueue.js

@@ -2,7 +2,7 @@
 
 const cds = require("@sap/cds");
 
-const { getConfigInstance } = require("../config");
+const config = require("../config");
 
 const COMPONENT_NAME = "eventQueue/WorkerQueue";
 
@@ -56,8 +56,7 @@ class WorkerQueue {
 module.exports = {
   getWorkerPoolInstance: () => {
     if (!instance) {
-      const configInstance = getConfigInstance();
-      instance = new WorkerQueue(configInstance.parallelTenantProcessing);
+      instance = new WorkerQueue(config.parallelTenantProcessing);
     }
     return instance;
   },

package/src/shared/cdsHelper.js

@@ -94,7 +94,7 @@ class TriggerRollback extends VError {
 }
 
 const getSubdomainForTenantId = async (tenantId) => {
-  if (!config.getConfigInstance().isMultiTenancy) {
+  if (!config.isMultiTenancy) {
     return null;
   }
   if (subdomainCache[tenantId]) {
@@ -111,7 +111,7 @@ const getSubdomainForTenantId = async (tenantId) => {
 };
 
 const getAllTenantIds = async () => {
-  if (!config.getConfigInstance().isMultiTenancy) {
+  if (!config.isMultiTenancy) {
     return null;
   }
   const ssp = await cds.connect.to("cds.xt.SaasProvisioningService");

package/src/shared/distributedLock.js

@@ -3,15 +3,10 @@
 const redis = require("./redis");
 const config = require("../config");
 const cdsHelper = require("./cdsHelper");
-const { getConfigInstance } = require("../config");
 
-const acquireLock = async (
-  context,
-  key,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout } = {}
-) => {
+const acquireLock = async (context, key, { tenantScoped = true, expiryTime = config.globalTxTimeout } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime);
   } else {
     return await _acquireLockDB(context, fullKey, expiryTime);
@@ -22,10 +17,10 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout, overrideValue = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, overrideValue = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, {
       value,
       overrideValue,
@@ -40,7 +35,7 @@ const setValueWithExpire = async (
 
 const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _releaseLockRedis(context, fullKey);
   } else {
     return await _releaseLockDb(context, fullKey);
@@ -49,7 +44,7 @@ const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
 
 const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _checkLockExistsRedis(context, fullKey);
   } else {
     return await _checkLockExistsDb(context, fullKey);
@@ -72,9 +67,8 @@ const _checkLockExistsRedis = async (context, fullKey) => {
 
 const _checkLockExistsDb = async (context, fullKey) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-checkExists", async (tx) => {
-    result = await tx.run(SELECT.one.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    result = await tx.run(SELECT.one.from(config.tableNameEventLock).where("code =", fullKey));
   });
   return result?.value;
 };
@@ -85,19 +79,17 @@ const _releaseLockRedis = async (context, fullKey) => {
 };
 
 const _releaseLockDb = async (context, fullKey) => {
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
-    await tx.run(DELETE.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    await tx.run(DELETE.from(config.tableNameEventLock).where("code =", fullKey));
   });
 };
 
 const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
     try {
       await tx.run(
-        INSERT.into(configInstance.tableNameEventLock).entries({
+        INSERT.into(config.tableNameEventLock).entries({
           code: fullKey,
           value,
         })
@@ -109,14 +101,14 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
       if (!overrideValue) {
         currentEntry = await tx.run(
           SELECT.one
-            .from(configInstance.tableNameEventLock)
-            .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
+            .from(config.tableNameEventLock)
+            .forUpdate({ wait: config.forUpdateTimeout })
             .where("code =", fullKey)
         );
       }
       if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
         await tx.run(
-          UPDATE.entity(configInstance.tableNameEventLock)
+          UPDATE.entity(config.tableNameEventLock)
             .set({
               createdAt: new Date().toISOString(),
               value,

package/src/shared/eventScheduler.js

@@ -13,11 +13,8 @@ class EventScheduler {
   constructor() {}
 
   scheduleEvent(tenantId, type, subType, startAfter) {
-    const configInstance = config.getConfigInstance();
-    const eventConfig = configInstance.getEventConfig(type, subType);
-    const scheduleWithoutDelay = configInstance.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
-    const roundUpDate = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
-    const key = [tenantId, type, subType, roundUpDate.toISOString()].join("##");
+    const { date, relative } = this.calculateOffset(type, subType, startAfter);
+    const key = [tenantId, type, subType, date.toISOString()].join("##");
     if (this.#scheduledEvents[key]) {
       return; // event combination already scheduled
     }
@@ -25,7 +22,7 @@ class EventScheduler {
     cds.log(COMPONENT_NAME).info("scheduling event queue run for delayed event", {
       type,
       subType,
-      delaySeconds: (roundUpDate.getTime() - Date.now()) / 1000,
+      delaySeconds: (date.getTime() - Date.now()) / 1000,
     });
     setTimeout(() => {
       delete this.#scheduledEvents[key];
@@ -34,10 +31,18 @@ class EventScheduler {
           tenantId,
           type,
           subType,
-          scheduledFor: roundUpDate.toISOString(),
+          scheduledFor: date.toISOString(),
         });
       });
-    }, roundUpDate.getTime() - Date.now()).unref();
+    }, relative).unref();
+  }
+
+  calculateOffset(type, subType, startAfter) {
+    const eventConfig = config.getEventConfig(type, subType);
+    const scheduleWithoutDelay = config.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
+    const date = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
+
+    return { date, relative: date.getTime() - Date.now() };
   }
 
   calculateFutureTime(date, seoncds) {