@cap-js-community/event-queue 1.2.5 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "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",
   "files": [

package/src/EventQueueError.js

@@ -17,7 +17,9 @@ const ERROR_CODES = {
   DUPLICATE_EVENT_REGISTRATION: "DUPLICATE_EVENT_REGISTRATION",
   NO_MANUEL_INSERT_OF_PERIODIC: "NO_MANUEL_INSERT_OF_PERIODIC",
   LOAD_HIGHER_THAN_LIMIT: "LOAD_HIGHER_THAN_LIMIT",
+  NOT_ALLOWED_PRIORITY: "NOT_ALLOWED_PRIORITY",
   SCHEMA_TENANT_MISMATCH: "SCHEMA_TENANT_MISMATCH",
+  GLOBAL_CDS_CONTEXT_MISMATCH: "GLOBAL_CDS_CONTEXT_MISMATCH",
 };
 
 const ERROR_CODES_META = {
@@ -64,9 +66,15 @@ const ERROR_CODES_META = {
   [ERROR_CODES.LOAD_HIGHER_THAN_LIMIT]: {
     message: "The defined load of an event is higher than the maximum defined limit. Check your configuration!",
   },
+  [ERROR_CODES.NOT_ALLOWED_PRIORITY]: {
+    message: "The supplied priority is not allowed. Only LOW, MEDIUM, HIGH is allowed!",
+  },
   [ERROR_CODES.SCHEMA_TENANT_MISMATCH]: {
     message: "The db client associated to the tenant context does not match! Processing will be skipped.",
   },
+  [ERROR_CODES.GLOBAL_CDS_CONTEXT_MISMATCH]: {
+    message: "The global cds context does not match the local cds context.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -225,6 +233,17 @@ class EventQueueError extends VError {
     );
   }
 
+  static priorityNotAllowed(priority, label) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.NOT_ALLOWED_PRIORITY];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.NOT_ALLOWED_PRIORITY,
+        info: { priority, label },
+      },
+      message
+    );
+  }
+
   static dbClientSchemaMismatch(tenantId, dbClientSchema, serviceManagerSchema) {
     const { message } = ERROR_CODES_META[ERROR_CODES.SCHEMA_TENANT_MISMATCH];
     return new EventQueueError(
@@ -235,6 +254,17 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static globalCdsContextNotMatchingLocal(globalProperties, localProperties) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.GLOBAL_CDS_CONTEXT_MISMATCH];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.GLOBAL_CDS_CONTEXT_MISMATCH,
+        info: { globalProperties, localProperties },
+      },
+      message
+    );
+  }
 }
 
 module.exports = EventQueueError;

package/src/EventQueueProcessorBase.js

@@ -70,6 +70,8 @@ class EventQueueProcessorBase {
     this.__txMap = {};
     this.__txRollback = {};
     this.__queueEntries = [];
+
+    this.#checkGlobalContextToLocalContext();
   }
 
   /**
@@ -533,7 +535,9 @@ class EventQueueProcessorBase {
   async getQueueEntriesAndSetToInProgress() {
     let result = [];
     const refDateStartAfter = new Date(Date.now() + this.#config.runInterval * 1.2);
+    this.#checkGlobalContextToLocalContext();
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
+      this.#checkGlobalContextToLocalContext();
       await this.checkTxConsistency(tx);
       const entries = await tx.run(
         SELECT.from(this.#config.tableNameEventQueue)
@@ -692,7 +696,7 @@ class EventQueueProcessorBase {
     } catch (err) {
       errorHandler(err);
     }
-    if (txSchema !== serviceManagerSchema) {
+    if (serviceManagerSchema && txSchema !== serviceManagerSchema) {
       const err = EventQueueError.dbClientSchemaMismatch(tx.context.tenant, txSchema, serviceManagerSchema);
       errorHandler(err);
       throw err;
@@ -724,6 +728,48 @@ class EventQueueProcessorBase {
     return entry.lastAttemptsTs;
   }
 
+  #checkGlobalContextToLocalContext() {
+    if (!this.#config.enableTxConsistencyCheck) {
+      return;
+    }
+    if (this.__context.tenant !== cds.context.tenant) {
+      throw EventQueueError.globalCdsContextNotMatchingLocal(
+        JSON.stringify(
+          {
+            correlationId: cds.context.id,
+            tenantId: cds.context.tenant,
+            timestamp: cds.context.timestamp,
+            base: JSON.stringify(
+              {
+                correlationId: cds.context.context?.id,
+                tenantId: cds.context.context?.tenant,
+                timestamp: cds.context.context?.timestamp,
+              },
+              null,
+              2
+            ),
+          },
+          null,
+          2
+        ),
+        JSON.stringify(
+          {
+            correlationId: this.__context.id,
+            tenantId: this.__context.tenant,
+            timestamp: this.__context.timestamp,
+            base: JSON.stringify({
+              correlationId: this.__context.context?.id,
+              tenantId: this.__context.context?.tenant,
+              timestamp: this.__context.context?.timestamp,
+            }),
+          },
+          null,
+          2
+        )
+      );
+    }
+  }
+
   #handleDelayedEvents(delayedEvents) {
     for (const delayedEvent of delayedEvents) {
       this.#eventSchedulerInstance.scheduleEvent(

package/src/config.js

@@ -5,6 +5,7 @@ const cds = require("@sap/cds");
 const { getEnvInstance } = require("./shared/env");
 const redis = require("./shared/redis");
 const EventQueueError = require("./EventQueueError");
+const { Priorities } = require("./constants");
 
 const FOR_UPDATE_TIMEOUT = 10;
 const GLOBAL_TX_TIMEOUT = 30 * 60 * 1000;
@@ -13,6 +14,7 @@ const REDIS_CONFIG_BLOCKLIST_CHANNEL = "REDIS_CONFIG_BLOCKLIST_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/config";
 const MIN_INTERVAL_SEC = 10;
 const DEFAULT_LOAD = 1;
+const DEFAULT_PRIORITY = Priorities.Medium;
 const SUFFIX_PERIODIC = "_PERIODIC";
 const COMMAND_BLOCK = "EVENT_QUEUE_EVENT_BLOCK";
 const COMMAND_UNBLOCK = "EVENT_QUEUE_EVENT_UNBLOCK";
@@ -24,6 +26,7 @@ const BASE_PERIODIC_EVENTS = [
   {
     type: "EVENT_QUEUE_BASE",
     subType: "DELETE_EVENTS",
+    priority: Priorities.Low,
     impl: "./housekeeping/EventQueueDeleteEvents",
     load: 1,
     interval: 86400, // 1 day,
@@ -51,8 +54,8 @@ class Config {
   #env;
   #eventMap;
   #updatePeriodicEvents;
-  #blockedPeriodicEvents;
-  #isPeriodicEventBlockedCb;
+  #blockedEvents;
+  #isEventBlockedCb;
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
   #userId;
@@ -76,7 +79,7 @@ class Config {
     this.#skipCsnCheck = null;
     this.#disableRedis = null;
     this.#env = getEnvInstance();
-    this.#blockedPeriodicEvents = {};
+    this.#blockedEvents = {};
   }
 
   getEventConfig(type, subType) {
@@ -100,7 +103,7 @@ class Config {
   }
 
   attachConfigChangeHandler() {
-    this.#attachBlocklistChangeHandler();
+    this.#attachBlockListChangeHandler();
     redis.subscribeRedisChannel(REDIS_CONFIG_CHANNEL, (messageData) => {
       try {
         const { key, value } = JSON.parse(messageData);
@@ -126,14 +129,14 @@ class Config {
     });
   }
 
-  #attachBlocklistChangeHandler() {
+  #attachBlockListChangeHandler() {
     redis.subscribeRedisChannel(REDIS_CONFIG_BLOCKLIST_CHANNEL, (messageData) => {
       try {
         const { command, key, tenant } = JSON.parse(messageData);
         if (command === COMMAND_BLOCK) {
-          this.#blockPeriodicEventLocalState(key, tenant);
+          this.#blockEventLocalState(key, tenant);
         } else {
-          this.#unblockPeriodicEventLocalState(key, tenant);
+          this.#unblockEventLocalState(key, tenant);
         }
       } catch (err) {
         this.#logger.error("could not parse event blocklist change", err, {
@@ -143,14 +146,14 @@ class Config {
     });
   }
 
-  blockPeriodicEvent(type, subType, tenant = "*") {
-    const typeWithSuffix = `${type}${SUFFIX_PERIODIC}`;
+  blockEvent(type, subType, isPeriodic, tenant = "*") {
+    const typeWithSuffix = `${type}${isPeriodic ? SUFFIX_PERIODIC : ""}`;
     const config = this.getEventConfig(typeWithSuffix, subType);
     if (!config) {
       return;
     }
     const key = this.generateKey(typeWithSuffix, subType);
-    this.#blockPeriodicEventLocalState(key, tenant);
+    this.#blockEventLocalState(key, tenant);
     if (!this.redisEnabled) {
       return;
     }
@@ -162,24 +165,24 @@ class Config {
       });
   }
 
-  #blockPeriodicEventLocalState(key, tenant) {
-    this.#blockedPeriodicEvents[key] ??= {};
-    this.#blockedPeriodicEvents[key][tenant] = true;
+  #blockEventLocalState(key, tenant) {
+    this.#blockedEvents[key] ??= {};
+    this.#blockedEvents[key][tenant] = true;
     return key;
   }
 
   clearPeriodicEventBlockList() {
-    this.#blockedPeriodicEvents = {};
+    this.#blockedEvents = {};
   }
 
-  unblockPeriodicEvent(type, subType, tenant = "*") {
-    const typeWithSuffix = `${type}${SUFFIX_PERIODIC}`;
+  unblockEvent(type, subType, isPeriodic, tenant = "*") {
+    const typeWithSuffix = `${type}${isPeriodic ? SUFFIX_PERIODIC : ""}`;
     const key = this.generateKey(typeWithSuffix, subType);
     const config = this.getEventConfig(typeWithSuffix, subType);
     if (!config) {
       return;
     }
-    this.#unblockPeriodicEventLocalState(key, tenant);
+    this.#unblockEventLocalState(key, tenant);
     if (!this.redisEnabled) {
       return;
     }
@@ -215,17 +218,17 @@ class Config {
     this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)] = eventConfig;
   }
 
-  #unblockPeriodicEventLocalState(key, tenant) {
-    const map = this.#blockedPeriodicEvents[key];
+  #unblockEventLocalState(key, tenant) {
+    const map = this.#blockedEvents[key];
     if (!map) {
       return;
     }
-    this.#blockedPeriodicEvents[key][tenant] = false;
+    this.#blockedEvents[key][tenant] = false;
     return key;
   }
 
-  isPeriodicEventBlocked(type, subType, tenant) {
-    const map = this.#blockedPeriodicEvents[this.generateKey(type, subType)];
+  isEventBlocked(type, subType, tenant) {
+    const map = this.#blockedEvents[this.generateKey(type, subType)];
     if (!map) {
       return false;
     }
@@ -248,12 +251,14 @@ class Config {
     config.periodicEvents = (config.periodicEvents ?? []).concat(BASE_PERIODIC_EVENTS.map((event) => ({ ...event })));
     this.#eventMap = config.events.reduce((result, event) => {
       event.load = event.load ?? DEFAULT_LOAD;
+      event.priority = event.priority ?? DEFAULT_PRIORITY;
       this.validateAdHocEvents(result, event);
       result[this.generateKey(event.type, event.subType)] = event;
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
       event.load = event.load ?? DEFAULT_LOAD;
+      event.priority = event.priority ?? DEFAULT_PRIORITY;
       event.type = `${event.type}${SUFFIX_PERIODIC}`;
       event.isPeriodic = true;
       this.validatePeriodicConfig(result, event);
@@ -371,12 +376,12 @@ class Config {
     this.#instanceLoadLimit = value;
   }
 
-  get isPeriodicEventBlockedCb() {
-    return this.#isPeriodicEventBlockedCb;
+  get isEventBlockedCb() {
+    return this.#isEventBlockedCb;
   }
 
-  set isPeriodicEventBlockedCb(value) {
-    this.#isPeriodicEventBlockedCb = value;
+  set isEventBlockedCb(value) {
+    this.#isEventBlockedCb = value;
   }
 
   get tableNameEventQueue() {

package/src/constants.js

@@ -13,4 +13,10 @@ module.exports = {
     alwaysCommit: "alwaysCommit",
     alwaysRollback: "alwaysRollback",
   },
+  Priorities: {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    VeryHigh: "veryHigh",
+  },
 };

package/src/processEventQueue.js

@@ -29,6 +29,10 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
       return;
     }
     baseInstance = new EventTypeClass(context, eventType, eventSubType, eventConfig);
+    if (await _checkEventIsBlocked(baseInstance)) {
+      return;
+    }
+
     const continueProcessing = await baseInstance.acquireDistributedLock();
     if (!continueProcessing) {
       return;
@@ -119,31 +123,6 @@ const reevaluateShouldContinue = (eventTypeInstance, iterationCounter, startTime
 };
 
 const processPeriodicEvent = async (context, eventTypeInstance) => {
-  const isPeriodicEventBlockedCb = config.isPeriodicEventBlockedCb;
-  const params = [eventTypeInstance.eventType, eventTypeInstance.eventSubType, eventTypeInstance.context.tenant];
-  let eventBlocked = false;
-  if (isPeriodicEventBlockedCb) {
-    try {
-      eventBlocked = await isPeriodicEventBlockedCb(...params);
-    } catch (err) {
-      eventBlocked = true;
-      eventTypeInstance.logger.error("skipping run because periodic event blocked check failed!", err, {
-        type: eventTypeInstance.eventType,
-        subType: eventTypeInstance.eventSubType,
-      });
-    }
-  } else {
-    eventBlocked = config.isPeriodicEventBlocked(...params);
-  }
-
-  if (eventBlocked) {
-    eventTypeInstance.logger.info("skipping run because periodic event is blocked by configuration", {
-      type: eventTypeInstance.eventType,
-      subType: eventTypeInstance.eventSubType,
-    });
-    return;
-  }
-
   try {
     let queueEntry;
     let processNext = true;
@@ -268,6 +247,41 @@ const processEventMap = async (eventTypeInstance) => {
   eventTypeInstance.endPerformanceTracerEvents();
 };
 
+const _checkEventIsBlocked = async (baseInstance) => {
+  const isEventBlockedCb = config.isEventBlockedCb;
+  let eventBlocked;
+  if (isEventBlockedCb) {
+    try {
+      eventBlocked = await isEventBlockedCb(
+        baseInstance.eventType,
+        baseInstance.eventSubType,
+        baseInstance.isPeriodicEvent,
+        baseInstance.context.tenant
+      );
+    } catch (err) {
+      eventBlocked = true;
+      baseInstance.logger.error("skipping run because periodic event blocked check failed!", err, {
+        type: baseInstance.eventType,
+        subType: baseInstance.eventSubType,
+      });
+    }
+  } else {
+    eventBlocked = config.isEventBlocked(
+      baseInstance.eventType,
+      baseInstance.eventSubType,
+      baseInstance.context.tenant
+    );
+  }
+
+  if (eventBlocked) {
+    baseInstance.logger.info("skipping run because periodic event is blocked by configuration", {
+      type: baseInstance.eventType,
+      subType: baseInstance.eventSubType,
+    });
+  }
+  return eventBlocked;
+};
+
 const _processEvent = async (eventTypeInstance, processContext, key, queueEntries, payload) => {
   try {
     const eventOutdated = await eventTypeInstance.isOutdatedAndKeepalive(queueEntries);

package/src/runner.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const { randomUUID } = require("crypto");
+const { AsyncResource } = require("async_hooks");
 
 const cds = require("@sap/cds");
 
@@ -14,6 +15,7 @@ const { getSubdomainForTenantId } = require("./shared/cdsHelper");
 const periodicEvents = require("./periodicEvents");
 const { hashStringTo32Bit } = require("./shared/common");
 const config = require("./config");
+const { Priorities } = require("./constants");
 
 const COMPONENT_NAME = "/eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
@@ -26,9 +28,9 @@ let singleRunDone;
 
 const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenant, _singleTenantDb);
 
-const multiTenancyDb = () => _scheduleFunction(_multiTenancyPeriodicEvents, _multiTenancyDb);
+const multiTenancyDb = () => _scheduleFunction(async () => {}, _multiTenancyDb);
 
-const multiTenancyRedis = () => _scheduleFunction(_multiTenancyPeriodicEvents, _multiTenancyRedis);
+const multiTenancyRedis = () => _scheduleFunction(async () => {}, _multiTenancyRedis);
 
 const _scheduleFunction = async (singleRunFn, periodicFn) => {
   const logger = cds.log(COMPONENT_NAME);
@@ -69,7 +71,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();
-  _checkAndTriggerPeriodicEventUpdate(tenantIds);
+  await _checkPeriodicEventUpdate(tenantIds);
 
   const runId = await _acquireRunId(emptyContext);
 
@@ -78,22 +80,21 @@ const _multiTenancyRedis = async () => {
     return;
   }
 
-  return _executeEventsAllTenants(tenantIds, runId);
+  return await _executeEventsAllTenants(tenantIds, runId);
 };
 
-const _checkAndTriggerPeriodicEventUpdate = (tenantIds) => {
+const _checkPeriodicEventUpdate = async (tenantIds) => {
   const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
-    _multiTenancyPeriodicEvents().catch((err) => {
+    return await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
       cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events!", err);
     });
-    return;
   }
   if (tenantIdHash && tenantIdHash !== hash) {
     tenantIdHash = hash;
     cds.log(COMPONENT_NAME).info("tenant id hash changed, triggering updating periodic events!");
-    _multiTenancyPeriodicEvents().catch((err) => {
+    return await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
       cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events!", err);
     });
   }
@@ -108,91 +109,103 @@ const _executeEventsAllTenants = (tenantIds, runId) => {
     return result;
   }, []);
 
-  return product.map(async ([tenantId, event]) => {
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const user = new cds.User.Privileged(config.userId);
-    const tenantContext = {
-      tenant: tenantId,
-      user,
-      // 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 label = `${event.type}_${event.subType}`;
-      return await WorkerQueue.instance.addToQueue(event.load, label, async () => {
+  return Promise.allSettled(
+    product.map(async ([tenantId, eventConfig]) => {
+      const subdomain = await getSubdomainForTenantId(tenantId);
+      const user = new cds.User.Privileged(config.userId);
+      const tenantContext = {
+        tenant: tenantId,
+        user,
+        // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+        http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+      };
+      const label = `${eventConfig.type}_${eventConfig.subType}`;
+      return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
+        return await cds.tx(tenantContext, async ({ context }) => {
+          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, eventConfig.subType, true);
+          } catch (err) {
+            cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+              tenantId,
+            });
+          }
+        });
+      });
+    })
+  );
+};
+
+const _executePeriodicEventsAllTenants = async (tenantIds, runId) => {
+  return await Promise.allSettled(
+    tenantIds.map(async (tenantId) => {
+      const label = `UPDATE_PERIODIC_EVENTS_${tenantId}`;
+      return await WorkerQueue.instance.addToQueue(1, label, Priorities.Low, async () => {
         try {
-          const lockId = `${runId}_${label}`;
-          const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-            expiryTime: eventQueueConfig.runInterval * 0.95,
+          const subdomain = await getSubdomainForTenantId(tenantId);
+          const user = new cds.User.Privileged(config.userId);
+          const tenantContext = {
+            tenant: tenantId,
+            user,
+            // 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 runEventCombinationForTenant(context, event.type, event.subType, true);
         } catch (err) {
           cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
             tenantId,
           });
         }
       });
-    });
-  });
+    })
+  );
 };
 
-const _executePeriodicEventsAllTenants = (tenantIds, runId) => {
-  tenantIds.forEach((tenantId) => {
-    const label = `UPDATE_PERIODIC_EVENTS_${tenantId}`;
-    WorkerQueue.instance.addToQueue(1, label, async () => {
-      try {
-        const subdomain = await getSubdomainForTenantId(tenantId);
-        const user = new cds.User.Privileged(config.userId);
-        const tenantContext = {
-          tenant: tenantId,
-          user,
-          // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-          http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-        };
-
+const _singleTenantDb = async (tenantId) => {
+  return Promise.allSettled(
+    eventQueueConfig.allEvents.map(async (eventConfig) => {
+      const label = `${eventConfig.type}_${eventConfig.subType}`;
+      const user = new cds.User.Privileged(config.userId);
+      const tenantContext = {
+        tenant: tenantId,
+        user,
+      };
+      return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
         return await cds.tx(tenantContext, async ({ context }) => {
-          const couldAcquireLock = await distributedLock.acquireLock(context, runId, {
-            expiryTime: eventQueueConfig.runInterval * 0.95,
-          });
-          if (!couldAcquireLock) {
-            return;
+          try {
+            const lockId = `${EVENT_QUEUE_RUN_ID}_${label}`;
+            const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
+              expiryTime: eventQueueConfig.runInterval * 0.95,
+            });
+            if (!couldAcquireLock) {
+              return;
+            }
+            await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, true);
+          } catch (err) {
+            cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+              tenantId,
+              redisEnabled: eventQueueConfig.redisEnabled,
+            });
           }
-          await _checkPeriodicEventsSingleTenant(context);
-        });
-      } catch (err) {
-        cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-          tenantId,
         });
-      }
-    });
-  });
-};
-
-const _singleTenantDb = async (tenantId) => {
-  return eventQueueConfig.allEvents.map((event) => {
-    const label = `${event.type}_${event.subType}`;
-    return WorkerQueue.instance.addToQueue(event.load, label, async () => {
-      try {
-        const context = new cds.EventContext({ tenant: tenantId });
-        const lockId = `${EVENT_QUEUE_RUN_ID}_${label}`;
-        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,
-          redisEnabled: eventQueueConfig.redisEnabled,
-        });
-      }
-    });
-  });
+      });
+    })
+  );
 };
 
 const _acquireRunId = async (context) => {
@@ -257,12 +270,13 @@ const runEventCombinationForTenant = async (context, type, subType, skipWorkerPo
     if (skipWorkerPool) {
       return await processEventQueue(context, type, subType);
     } else {
-      const config = eventQueueConfig.getEventConfig(type, subType);
+      const eventConfig = eventQueueConfig.getEventConfig(type, subType);
       const label = `${type}_${subType}`;
       return await WorkerQueue.instance.addToQueue(
-        config.load,
+        eventConfig.load,
         label,
-        async () => await processEventQueue(context, type, subType)
+        eventConfig.priority,
+        AsyncResource.bind(async () => await processEventQueue(context, type, subType))
       );
     }
   } catch (err) {
@@ -280,19 +294,19 @@ const _multiTenancyDb = async () => {
   try {
     logger.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
-    _checkAndTriggerPeriodicEventUpdate(tenantIds);
-    return _executeEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
+    await _checkPeriodicEventUpdate(tenantIds);
+    return await _executeEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for event queue processing! Next try after defined interval.", err);
   }
 };
 
-const _multiTenancyPeriodicEvents = async () => {
+const _multiTenancyPeriodicEvents = async (tenantIds) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
     logger.info("executing event queue update periodic events");
-    const tenantIds = await cdsHelper.getAllTenantIds();
-    _executePeriodicEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_PERIODIC_EVENT);
+    tenantIds = tenantIds ?? (await cdsHelper.getAllTenantIds());
+    return await _executePeriodicEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_PERIODIC_EVENT);
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for updating periodic event processing!", err);
   }

package/src/shared/WorkerQueue.js

@@ -4,15 +4,30 @@ const cds = require("@sap/cds");
 
 const config = require("../config");
 const EventQueueError = require("../EventQueueError");
+const { Priorities } = require("../constants");
+const SetIntervalDriftSafe = require("./SetIntervalDriftSafe");
+
+const PRIORITIES = Object.values(Priorities).reverse();
+const PRIORITY_MULTIPLICATOR = PRIORITIES.reduce((result, element, index) => {
+  result[element] = index + 1;
+  return result;
+}, {});
 
 const COMPONENT_NAME = "/eventQueue/WorkerQueue";
 const NANO_TO_MS = 1e6;
+const MIN_TO_MS = 60 * 1000;
+const INCREASE_PRIORITY_AFTER = 3;
+
+let lastLogTs;
+
 const THRESHOLD = {
   INFO: 35 * 1000,
   WARN: 55 * 1000,
   ERROR: 75 * 1000,
 };
 
+const CHECK_INTERVAL_QUEUE = 60 * 1000;
+
 class WorkerQueue {
   #concurrencyLimit;
   #runningPromises;
@@ -28,24 +43,53 @@ class WorkerQueue {
     }
     this.#runningPromises = [];
     this.#runningLoad = 0;
-    this.#queue = [];
+    this.#queue = PRIORITIES.reduce((result, priority) => {
+      result[priority] = [];
+      return result;
+    }, {});
+
+    const runner = new SetIntervalDriftSafe(CHECK_INTERVAL_QUEUE);
+    runner.run(this.#adjustPriority.bind(this));
   }
 
-  addToQueue(load, label, cb) {
+  addToQueue(load, label, priority = Priorities.Medium, cb) {
     if (load > this.#concurrencyLimit) {
       throw EventQueueError.loadHigherThanLimit(load, label);
     }
 
+    if (!PRIORITIES.includes(priority)) {
+      throw EventQueueError.priorityNotAllowed(priority, label);
+    }
+
     const startTime = process.hrtime.bigint();
     const p = new Promise((resolve, reject) => {
-      this.#queue.push([load, label, cb, resolve, reject, startTime]);
+      this.#queue[priority].push([load, label, cb, resolve, reject, startTime]);
     });
-    this._checkForNext();
+    this.#checkForNext();
     return p;
   }
 
-  _executeFunction(load, label, cb, resolve, reject, startTime) {
-    this.checkAndLogWaitingTime(startTime, label);
+  #adjustPriority() {
+    const checkTime = process.hrtime.bigint();
+    const priorityValues = Object.values(Priorities);
+
+    for (let i = 0; i < priorityValues.length - 1; i++) {
+      const priority = priorityValues[i];
+      const nextPriority = priorityValues[i + 1];
+      for (let i = 0; i < this.queue[priority].length; i++) {
+        const queueEntry = this.queue[priority][i];
+        const startTime = queueEntry[6] ?? queueEntry[5];
+        if (Math.round(Number(checkTime - startTime) / NANO_TO_MS) > INCREASE_PRIORITY_AFTER * MIN_TO_MS) {
+          const [entry] = this.queue[priority].splice(i, 1);
+          entry.push(checkTime);
+          this.queue[nextPriority].push(entry);
+        }
+      }
+    }
+  }
+
+  _executeFunction(load, label, cb, resolve, reject, startTime, priority) {
+    this.#checkAndLogWaitingTime(startTime, label, priority);
     const promise = Promise.resolve().then(() => cb());
     this.#runningPromises.push(promise);
     this.#runningLoad = this.#runningLoad + load;
@@ -53,7 +97,7 @@ class WorkerQueue {
       .finally(() => {
         this.#runningLoad = this.#runningLoad - load;
         this.#runningPromises.splice(this.#runningPromises.indexOf(promise), 1);
-        this._checkForNext();
+        this.#checkForNext();
       })
       .then((...results) => {
         resolve(...results);
@@ -62,15 +106,32 @@ class WorkerQueue {
         cds.log(COMPONENT_NAME).error("Error happened in WorkQueue. Errors should be caught before!", err, { label });
         reject(err);
       });
+
+    if (this.#runningLoad !== this.#concurrencyLimit) {
+      this.#checkForNext();
+    }
   }
 
-  _checkForNext() {
-    const load = this.#queue[0]?.[0];
-    if (!this.#queue.length || this.#runningLoad + load > this.#concurrencyLimit) {
+  #checkForNext() {
+    if (!this.#queue.length && this.#runningLoad === this.#concurrencyLimit) {
       return;
     }
-    const args = this.#queue.shift();
-    this._executeFunction(...args);
+
+    let entryFound = false;
+    for (const priority of PRIORITIES) {
+      for (let i = 0; i < this.#queue[priority].length; i++) {
+        const [load] = this.#queue[priority][i];
+        if (this.#runningLoad + load <= this.#concurrencyLimit) {
+          const [args] = this.#queue[priority].splice(i, 1);
+          this._executeFunction(...args, priority);
+          entryFound = true;
+          break;
+        }
+      }
+      if (entryFound) {
+        break;
+      }
+    }
   }
 
   get runningPromises() {
@@ -87,14 +148,24 @@ class WorkerQueue {
     return WorkerQueue.#instance;
   }
 
-  checkAndLogWaitingTime(startTime, label) {
+  get queue() {
+    return this.#queue;
+  }
+
+  #checkAndLogWaitingTime(startTime, label, priority) {
+    const ts = Date.now();
+    if (ts - lastLogTs <= 1000) {
+      return;
+    }
+    lastLogTs = ts;
     const diffMs = Math.round(Number(process.hrtime.bigint() - startTime) / NANO_TO_MS);
+    const priorityMultiplication = PRIORITY_MULTIPLICATOR[priority];
     let logLevel;
-    if (diffMs >= THRESHOLD.ERROR) {
+    if (diffMs >= THRESHOLD.ERROR * priorityMultiplication) {
       logLevel = "error";
-    } else if (diffMs >= THRESHOLD.WARN) {
+    } else if (diffMs >= THRESHOLD.WARN * priorityMultiplication) {
       logLevel = "warn";
-    } else if (diffMs >= THRESHOLD.INFO) {
+    } else if (diffMs >= THRESHOLD.INFO * priorityMultiplication) {
       logLevel = "info";
     } else {
       logLevel = "debug";