@cap-js-community/event-queue 1.11.0-beta.5 → 2.0.0-beta.0

package/src/index.d.ts

@@ -169,7 +169,12 @@ export function publishEvent(
   }
 ): Promise<any>;
 
-export function processEventQueue(context: cds.EventContext, eventType: string, eventSubType: string): Promise<any>;
+export function processEventQueue(
+  context: cds.EventContext,
+  eventType: string,
+  eventSubType: string,
+  namespace: string
+): Promise<any>;
 
 export function triggerEventProcessingRedis(
   tenantId: string,
@@ -180,20 +185,16 @@ export function triggerEventProcessingRedis(
 declare class Config {
   constructor();
 
-  getEventConfig(type: any, subType: any): any;
+  getEventConfig(type: string, subType: string, namespace: string): any;
   isCapOutboxEvent(type: any): boolean;
-  hasEventAfterCommitFlag(type: any, subType: any): any;
-  shouldBeProcessedInThisApplication(type: any, subType: any): boolean;
+  hasEventAfterCommitFlag(type: any, subType: any, namespace: string): any;
+  shouldBeProcessedInThisApplication(type: any, subType: any, namespace: string): boolean;
   checkRedisEnabled(): any;
   attachConfigChangeHandler(): void;
   attachRedisUnsubscribeHandler(): void;
   executeUnsubscribeHandlers(tenantId: any): void;
-  handleUnsubscribe(tenantId: any): void;
   attachUnsubscribeHandler(cb: any): void;
   publishConfigChange(key: any, value: any): void;
-  blockEvent(type: any, subType: any, isPeriodic: any, tenant?: string): void;
-  clearPeriodicEventBlockList(): void;
-  unblockEvent(type: any, subType: any, isPeriodic: any, tenant?: string): void;
   addCAPOutboxEventBase(serviceName: any, config: any): void;
   isEventBlocked(type: any, subType: any, isPeriodicEvent: any, tenant: any): any;
   set isEventQueueActive(value: boolean);
@@ -205,7 +206,7 @@ declare class Config {
   isTenantUnsubscribed(tenantId: any): any;
   get events(): any;
   get periodicEvents(): any;
-  isPeriodicEvent(type: any, subType: any): any;
+  isPeriodicEvent(type: any, subType: any, namespace: string): any;
   get allEvents(): any;
   set forUpdateTimeout(value: number);
   get forUpdateTimeout(): number;

package/src/initialize.js

@@ -22,7 +22,6 @@ const readFileAsync = promisify(fs.readFile);
 
 const VERROR_CLUSTER_NAME = "EventQueueInitialization";
 const COMPONENT = "eventQueue/initialize";
-const TIMEOUT_SHUTDOWN = 2500;
 
 const CONFIG_VARS = [
   ["configFilePath", null],
@@ -48,6 +47,8 @@ const CONFIG_VARS = [
   ["crashOnRedisUnavailable", false],
   ["enableAdminService", false],
   ["disableProcessingOfSuspendedTenants", true],
+  ["namespace", "default"],
+  ["processingNamespaces", ["default"]],
 ];
 
 /**
@@ -74,6 +75,8 @@ const CONFIG_VARS = [
  * @param {string} [options.randomOffsetPeriodicEvents=null] - Default random offset for periodic events.
  * @param {string} [options.publishEventBlockList=true] - If redis is available event blocklist is distributed to all application instances
  * @param {string} [options.crashOnRedisUnavailable=true] - If enabled an error is thrown if the redis connection check is not successful
+ * @param {string} [options.namespace=default] - Default namespace in which events are published
+ * @param {string} [options.processingNamespaces=[default]] - Namespaces which the application processes
  */
 const initialize = async (options = {}) => {
   if (config.initialized) {
@@ -101,7 +104,7 @@ const initialize = async (options = {}) => {
     }
   });
   if (redisEnabled) {
-    config.redisEnabled = await redis.connectionCheck(config.redisOptions);
+    config.redisEnabled = await redis.connectionCheck();
     if (!config.redisEnabled && config.crashOnRedisUnavailable) {
       throw EventQueueError.redisConnectionFailure();
     }
@@ -148,7 +151,7 @@ const readConfigFromFile = async (configFilepath) => {
 
 const registerEventProcessors = () => {
   _registerUnsubscribe();
-  config.redisEnabled && config.attachRedisUnsubscribeHandler();
+  config.redisEnabled && redis.attachRedisUnsubscribeHandler();
 
   if (!config.registerAsEventProcessor) {
     return;
@@ -158,7 +161,6 @@ const registerEventProcessors = () => {
 
   if (config.redisEnabled) {
     redisSub.initEventQueueRedisSubscribe();
-    config.attachConfigChangeHandler();
     if (config.isMultiTenancy) {
       runner.multiTenancyRedis().catch(errorHandler);
     } else {
@@ -203,24 +205,7 @@ const mixConfigVarsWithEnv = (options) => {
 };
 
 const registerCdsShutdown = () => {
-  cds.on("shutdown", async () => {
-    return await new Promise((resolve) => {
-      let timeoutRef;
-      timeoutRef = setTimeout(() => {
-        clearTimeout(timeoutRef);
-        cds.log(COMPONENT).info("shutdown timeout reached - some locks might not have been released!");
-        resolve();
-      }, TIMEOUT_SHUTDOWN);
-      distributedLock.shutdownHandler().then(() => {
-        Promise.allSettled(
-          config.redisEnabled ? [redis.closeMainClient(), redis.closeSubscribeClient()] : [Promise.resolve()]
-        ).then((result) => {
-          clearTimeout(timeoutRef);
-          resolve(result);
-        });
-      });
-    });
-  });
+  redis.registerShutdownHandler(distributedLock.shutdownHandler);
 };
 
 const registerCleanupForDevDb = async () => {
@@ -250,7 +235,7 @@ const _registerUnsubscribe = () => {
         });
         ds.after("unsubscribe", async (_, req) => {
           const { tenant } = req.data;
-          config.handleUnsubscribe(tenant);
+          redis.handleUnsubscribe(tenant);
         });
       })
       .catch(

package/src/outbox/eventQueueAsOutbox.js

@@ -9,7 +9,7 @@ const OUTBOXED = Symbol("outboxed");
 const UNBOXED = Symbol("unboxed");
 const CDS_EVENT_TYPE = "CAP_OUTBOX";
 const COMPONENT_NAME = "/eventQueue/eventQueueAsOutbox";
-const EVENT_QUEUE_SPECIFIC_FIELDS = ["startAfter", "referenceEntity", "referenceEntityKey"];
+const EVENT_QUEUE_SPECIFIC_FIELDS = ["startAfter", "referenceEntity", "referenceEntityKey", "namespace"];
 
 function outboxed(srv, customOpts) {
   if (!(new.target || customOpts)) {
@@ -23,7 +23,9 @@ function outboxed(srv, customOpts) {
   let outboxOpts = Object.assign(
     {},
     (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
+    (typeof cds.requires.queue === "object" && cds.requires.queue) || {},
     (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
+    (typeof srv.options?.queued === "object" && srv.options.queued) || {},
     customOpts || {}
   );
 
@@ -43,7 +45,9 @@ function outboxed(srv, customOpts) {
     outboxOpts = Object.assign(
       {},
       (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
+      (typeof cds.requires.queue === "object" && cds.requires.queue) || {},
       (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
+      (typeof srv.options?.queued === "object" && srv.options.queued) || {},
       customOpts || {}
     );
     config.addCAPOutboxEventBase(srv.name, outboxOpts);
@@ -52,8 +56,9 @@ function outboxed(srv, customOpts) {
       outboxOpts = config.addCAPOutboxEventSpecificAction(srv.name, req.event);
     }
 
+    const namespace = (specificSettings ?? outboxOpts).namespace ?? config.namespace;
     if (["persistent-outbox", "persistent-queue"].includes(outboxOpts.kind)) {
-      await _mapToEventAndPublish(context, srv.name, req, !!specificSettings);
+      await _mapToEventAndPublish(context, srv.name, req, !!specificSettings, namespace);
       return;
     }
     context.on("succeeded", async () => {
@@ -79,7 +84,7 @@ function unboxed(srv) {
   return srv[UNBOXED] || srv;
 }
 
-const _mapToEventAndPublish = async (context, name, req, actionSpecific) => {
+const _mapToEventAndPublish = async (context, name, req, actionSpecific, namespace) => {
   const eventQueueSpecificValues = {};
   for (const header in req.headers ?? {}) {
     for (const field of EVENT_QUEUE_SPECIFIC_FIELDS) {
@@ -100,12 +105,17 @@ const _mapToEventAndPublish = async (context, name, req, actionSpecific) => {
     ...(req.query && { query: req.query }),
   };
 
-  await publishEvent(cds.tx(context), {
-    type: CDS_EVENT_TYPE,
-    subType: actionSpecific ? [name, req.event].join(".") : name,
-    payload: JSON.stringify(event),
-    ...eventQueueSpecificValues,
-  });
+  await publishEvent(
+    cds.tx(context),
+    {
+      type: CDS_EVENT_TYPE,
+      subType: actionSpecific ? [name, req.event].join(".") : name,
+      payload: JSON.stringify(event),
+      namespace: eventQueueSpecificValues.namespace ?? namespace,
+      ...eventQueueSpecificValues,
+    },
+    { allowNotExistingConfiguration: !!eventQueueSpecificValues.namespace }
+  );
 };
 
 const isUnrecoverable = (service, error) => {

package/src/periodicEvents.js

@@ -21,11 +21,11 @@ const checkAndInsertPeriodicEvents = async (context) => {
   const tx = cds.tx(context);
   const baseCqn = SELECT.from(eventConfig.tableNameEventQueue)
     .where([
-      { list: [{ ref: ["type"] }, { ref: ["subType"] }] },
+      { list: [{ ref: ["type"] }, { ref: ["subType"] }, { ref: ["namespace"] }] },
       "IN",
       {
         list: eventConfig.periodicEvents.map((periodicEvent) => ({
-          list: [{ val: periodicEvent.type }, { val: periodicEvent.subType }],
+          list: [{ val: periodicEvent.type }, { val: periodicEvent.subType }, { val: periodicEvent.namespace }],
         })),
       },
       "AND",
@@ -35,8 +35,8 @@ const checkAndInsertPeriodicEvents = async (context) => {
         list: [{ val: EventProcessingStatus.Open }, { val: EventProcessingStatus.InProgress }],
       },
     ])
-    .groupBy("type", "subType", "createdAt")
-    .columns(["type", "subType", "createdAt", "max(startAfter) as startAfter"]);
+    .groupBy("type", "subType", "createdAt", "namespace")
+    .columns(["type", "subType", "createdAt", "namespace", "max(startAfter) as startAfter"]);
   const currentPeriodEvents = await tx.run(baseCqn);
   currentPeriodEvents.length &&
     (await tx.run(_addWhere(SELECT.from(eventConfig.tableNameEventQueue).columns("ID"), currentPeriodEvents)));
@@ -56,7 +56,7 @@ const checkAndInsertPeriodicEvents = async (context) => {
     (result, event) => {
       const existingEvent = exitingEventMap[_generateKey(event)];
       if (existingEvent) {
-        const config = eventConfig.getEventConfig(existingEvent.type, existingEvent.subType);
+        const config = eventConfig.getEventConfig(existingEvent.type, existingEvent.subType, existingEvent.namespace);
         if (config.cron) {
           result.existingEventsCron.push(exitingEventMap[_generateKey(event)]);
         } else {
@@ -110,7 +110,7 @@ const _addWhere = (cqnBase, events) => {
 
 const _determineChangedInterval = (existingEvents, currentDate) => {
   return existingEvents.filter((existingEvent) => {
-    const config = eventConfig.getEventConfig(existingEvent.type, existingEvent.subType);
+    const config = eventConfig.getEventConfig(existingEvent.type, existingEvent.subType, existingEvent.namespace);
     const eventStartAfter = new Date(existingEvent.startAfter);
     // check if too far in future
     const dueInWithNewInterval = new Date(currentDate.getTime() + config.interval * 1000);
@@ -120,7 +120,7 @@ const _determineChangedInterval = (existingEvents, currentDate) => {
 
 const _determineChangedCron = (existingEventsCron) => {
   return existingEventsCron.filter((event) => {
-    const config = eventConfig.getEventConfig(event.type, event.subType);
+    const config = eventConfig.getEventConfig(event.type, event.subType, event.namespace);
     const eventStartAfter = new Date(event.startAfter);
     const eventCreatedAt = new Date(event.createdAt);
     const randomOffset = config.randomOffset ?? eventConfig.randomOffsetPeriodicEvents ?? 0;
@@ -141,9 +141,9 @@ const _insertPeriodEvents = async (tx, events, now) => {
   const chunks = Math.ceil(events.length / CHUNK_SIZE_INSERT_PERIODIC_EVENTS);
   const logger = cds.log(COMPONENT_NAME);
   const eventsToBeInserted = events.map((event) => {
-    const base = { type: event.type, subType: event.subType };
+    const base = { type: event.type, subType: event.subType, namespace: event.namespace };
     let startTime = now;
-    const config = eventConfig.getEventConfig(event.type, event.subType);
+    const config = eventConfig.getEventConfig(event.type, event.subType, event.namespace);
     if (config.cron) {
       startTime = CronExpressionParser.parse(config.cron, {
         currentDate: now,
@@ -156,11 +156,12 @@ const _insertPeriodEvents = async (tx, events, now) => {
 
   processChunkedSync(eventsToBeInserted, CHUNK_SIZE_INSERT_PERIODIC_EVENTS, (chunk) => {
     logger.info(`${counter}/${chunks} | inserting chunk of changed or new periodic events`, {
-      events: chunk.map(({ type, subType, startAfter }) => {
-        const { interval, cron } = eventConfig.getEventConfig(type, subType);
+      events: chunk.map(({ namespace, type, subType, startAfter }) => {
+        const { interval, cron } = eventConfig.getEventConfig(type, subType, namespace);
         return {
           type,
           subType,
+          namespace,
           ...(startAfter && { startAfter }),
           ...(interval && { interval }),
           ...(cron && { cron }),
@@ -175,7 +176,7 @@ const _insertPeriodEvents = async (tx, events, now) => {
   tx._skipEventQueueBroadcase = false;
 };
 
-const _generateKey = ({ type, subType }) => [type, subType].join("##");
+const _generateKey = ({ type, subType, namespace }) => [namespace, type, subType].join("##");
 
 module.exports = {
   checkAndInsertPeriodicEvents,

package/src/processEventQueue.js

@@ -13,14 +13,14 @@ const { trace } = require("./shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/processEventQueue";
 
-const processEventQueue = async (context, eventType, eventSubType) => {
+const processEventQueue = async (context, eventType, eventSubType, namespace = config.namespace) => {
   let iterationCounter = 0;
   let shouldContinue = true;
   let baseInstance;
   let startTime = new Date();
   try {
     let eventTypeInstance;
-    const eventConfig = config.getEventConfig(eventType, eventSubType);
+    const eventConfig = config.getEventConfig(eventType, eventSubType, namespace);
     const [err, EventTypeClass] = await resilientRequire(eventConfig);
     if (!eventConfig || err || !(typeof EventTypeClass.constructor === "function")) {
       cds.log(COMPONENT_NAME).error("No Implementation found in the provided configuration file.", {
@@ -287,14 +287,6 @@ const _checkEventIsBlocked = async (baseInstance) => {
         subType: baseInstance.eventSubType,
       });
     }
-  } else {
-    // TODO: we should be able to get rid of baseInstance.isPeriodicEvent with rawEventType
-    eventBlocked = config.isEventBlocked(
-      baseInstance.eventType,
-      baseInstance.eventSubType,
-      baseInstance.isPeriodicEvent,
-      baseInstance.context.tenant
-    );
   }
 
   if (!eventBlocked) {
@@ -310,7 +302,11 @@ const _checkEventIsBlocked = async (baseInstance) => {
   }
 
   if (!eventBlocked) {
-    eventBlocked = !config.shouldBeProcessedInThisApplication(baseInstance.rawEventType, baseInstance.eventSubType);
+    eventBlocked = !config.shouldBeProcessedInThisApplication(
+      baseInstance.rawEventType,
+      baseInstance.eventSubType,
+      baseInstance.namespace
+    );
   }
 
   return eventBlocked;

package/src/publishEvent.js

@@ -35,23 +35,28 @@ const openTelemetry = require("./shared/openTelemetry");
 const publishEvent = async (
   tx,
   events,
-  { skipBroadcast = false, skipInsertEventsBeforeCommit = false, addTraceContext = true } = {}
+  {
+    skipBroadcast = false,
+    skipInsertEventsBeforeCommit = false,
+    addTraceContext = true,
+    allowNotExistingConfiguration = false,
+  } = {}
 ) => {
   if (!config.initialized) {
     throw EventQueueError.notInitialized();
   }
   const eventsForProcessing = Array.isArray(events) ? events : [events];
   for (const event of eventsForProcessing) {
-    const { type, subType, startAfter } = event;
-    const eventConfig = config.getEventConfig(type, subType);
-    if (!eventConfig) {
+    const { type, subType, startAfter, namespace } = event;
+    const eventConfig = config.getEventConfig(type, subType, namespace);
+    if (!eventConfig && !allowNotExistingConfiguration) {
       throw EventQueueError.unknownEventType(type, subType);
     }
     if (startAfter && !common.isValidDate(startAfter)) {
       throw EventQueueError.malformedDate(startAfter);
     }
 
-    if (eventConfig.isPeriodic) {
+    if (eventConfig?.isPeriodic) {
       throw EventQueueError.manuelPeriodicEventInsert(type, subType);
     }
 
@@ -63,9 +68,13 @@ const publishEvent = async (
       event.context = JSON.stringify({ traceContext: openTelemetry.getCurrentTraceContext() });
     }
 
-    if (eventConfig.timeBucket && !(startAfter in event)) {
+    if (eventConfig?.timeBucket && !(startAfter in event)) {
       event.startAfter = CronExpressionParser.parse(eventConfig.timeBucket).next().toISOString();
     }
+
+    if (event.namespace === undefined) {
+      event.namespace = config.namespace;
+    }
   }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);

package/src/redis/redisPub.js

@@ -69,15 +69,15 @@ const broadcastEvent = async (tenantId, events, forceBroadcast = false) => {
     }
     await cds.tx({ tenant: tenantId }, async ({ context }) => {
       await trace(context, "broadcast-inserted-events", async () => {
-        for (const { type, subType } of events) {
-          const eventConfig = config.getEventConfig(type, subType);
+        for (const { type, subType, namespace } of events) {
+          const eventConfig = config.getEventConfig(type, subType, namespace);
           if (!eventConfig) {
             continue;
           }
           for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
             const result = eventConfig.multiInstanceProcessing
               ? false
-              : await distributedLock.checkLockExistsAndReturnValue(context, [type, subType].join("##"));
+              : await distributedLock.checkLockExists(context, [namespace, type, subType].join("##"));
             if (result) {
               logger.debug("skip publish redis event as no lock is available", {
                 type,
@@ -98,9 +98,8 @@ const broadcastEvent = async (tenantId, events, forceBroadcast = false) => {
               subType,
             });
             await redis.publishMessage(
-              config.redisOptions,
-              EVENT_MESSAGE_CHANNEL,
-              JSON.stringify({ lockId: cds.utils.uuid(), tenantId, type, subType })
+              [namespace, EVENT_MESSAGE_CHANNEL].join("##"),
+              JSON.stringify({ lockId: cds.utils.uuid(), tenantId, type, subType, namespace })
             );
             break;
           }
@@ -128,9 +127,12 @@ const _processLocalWithoutRedis = async (tenantId, events) => {
       };
     }
 
-    for (const { type, subType } of events) {
+    for (const { type, subType, namespace } of events) {
+      if (!config.shouldProcessNamespace(namespace)) {
+        continue;
+      }
       await cds.tx(context, async ({ context }) => {
-        await runEventCombinationForTenant(context, type, subType, { shouldTrace: true });
+        await runEventCombinationForTenant(context, type, subType, namespace, { shouldTrace: true });
       });
     }
   }

package/src/redis/redisSub.js

@@ -16,13 +16,16 @@ const initEventQueueRedisSubscribe = () => {
     return;
   }
   initEventQueueRedisSubscribe._initDone = true;
-  redis.subscribeRedisChannel(config.redisOptions, EVENT_MESSAGE_CHANNEL, _messageHandlerProcessEvents);
+
+  config.processingNamespaces.forEach((namespace) => {
+    redis.subscribeRedisChannel([namespace, EVENT_MESSAGE_CHANNEL].join("##"), _messageHandlerProcessEvents);
+  });
 };
 
 const _messageHandlerProcessEvents = async (messageData) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const { lockId, tenantId, type, subType } = JSON.parse(messageData);
+    const { lockId, tenantId, type, subType, namespace } = JSON.parse(messageData);
     const tenantShouldBeProcessed = await common.isTenantIdValidCb(TenantIdCheckTypes.eventProcessing, tenantId);
     if (!tenantShouldBeProcessed) {
       return;
@@ -41,7 +44,7 @@ const _messageHandlerProcessEvents = async (messageData) => {
     }
 
     const [serviceNameOrSubType, actionName] = subType.split(".");
-    if (!config.getEventConfig(type, subType)) {
+    if (!config.getEventConfig(type, subType, namespace)) {
       if (config.isCapOutboxEvent(type)) {
         try {
           const service = await cds.connect.to(serviceNameOrSubType);
@@ -68,7 +71,12 @@ const _messageHandlerProcessEvents = async (messageData) => {
       }
     }
 
-    if (!(config.getEventConfig(type, subType) && config.shouldBeProcessedInThisApplication(type, subType))) {
+    if (
+      !(
+        config.getEventConfig(type, subType, namespace) &&
+        config.shouldBeProcessedInThisApplication(type, subType, namespace)
+      )
+    ) {
       logger.debug("event is not configured to be processed on this app-name", {
         tenantId,
         type,
@@ -87,7 +95,10 @@ const _messageHandlerProcessEvents = async (messageData) => {
     };
 
     return await cds.tx(tenantContext, async ({ context }) => {
-      return await runnerHelper.runEventCombinationForTenant(context, type, subType, { lockId, shouldTrace: true });
+      return await runnerHelper.runEventCombinationForTenant(context, type, subType, namespace, {
+        lockId,
+        shouldTrace: true,
+      });
     });
   } catch (err) {
     logger.error("could not parse event information", {

package/src/runner/openEvents.js

@@ -14,7 +14,9 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const entries = await tx.run(
     SELECT.from(eventConfig.tableNameEventQueue)
       .where(
-        "( startAfter IS NULL OR startAfter <=",
+        "namespace IN",
+        config.processingNamespaces,
+        "AND ( startAfter IS NULL OR startAfter <=",
         refDateStartAfter.toISOString(),
         " ) AND ( status =",
         EventProcessingStatus.Open,
@@ -30,12 +32,12 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
         new Date(startTime.getTime() - 30 * MS_IN_DAYS).toISOString(),
         ")"
       )
-      .columns("type", "subType")
-      .groupBy("type", "subType")
+      .columns("type", "subType", "namespace")
+      .groupBy("type", "subType", "namespace")
   );
 
   const result = [];
-  for (const { type, subType } of entries) {
+  for (const { type, subType, namespace } of entries) {
     if (eventConfig.isCapOutboxEvent(type)) {
       const [srvName, actionName] = subType.split(".");
       try {
@@ -48,24 +50,24 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
           if (actionName) {
             config.addCAPOutboxEventSpecificAction(srvName, actionName);
           }
-          if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
-            result.push({ type, subType });
+          if (eventConfig.shouldBeProcessedInThisApplication(type, subType, namespace)) {
+            result.push({ namespace, type, subType });
           }
         }
       } catch {
         /* ignore catch */
       } finally {
         if (!filterAppSpecificEvents) {
-          result.push({ type, subType });
+          result.push({ namespace, type, subType });
         }
       }
     } else {
       if (filterAppSpecificEvents) {
         if (
-          eventConfig.getEventConfig(type, subType) &&
-          eventConfig.shouldBeProcessedInThisApplication(type, subType)
+          eventConfig.getEventConfig(type, subType, namespace) &&
+          eventConfig.shouldBeProcessedInThisApplication(type, subType, namespace)
         ) {
-          result.push({ type, subType });
+          result.push({ namespace, type, subType });
         }
       } else {
         result.push({ type, subType });

package/src/runner/runner.js

@@ -216,8 +216,8 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
 
     promises.concat(
       events.map(async (openEvent) => {
-        const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType);
-        const label = `${eventConfig.type}_${eventConfig.subType}`;
+        const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
+        const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
         return await WorkerQueue.instance.addToQueue(
           eventConfig.load,
           label,
@@ -237,9 +237,15 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
                     if (!couldAcquireLock) {
                       return;
                     }
-                    await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
-                      skipWorkerPool: true,
-                    });
+                    await runEventCombinationForTenant(
+                      context,
+                      eventConfig.type,
+                      eventConfig.subType,
+                      openEvent.namespace,
+                      {
+                        skipWorkerPool: true,
+                      }
+                    );
                   } catch (err) {
                     cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
                       tenantId,
@@ -304,8 +310,8 @@ const _singleTenantDb = async () => {
 
   return await Promise.allSettled(
     events.map(async (openEvent) => {
-      const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType);
-      const label = `${eventConfig.type}_${eventConfig.subType}`;
+      const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
+      const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
       return await WorkerQueue.instance.addToQueue(
         eventConfig.load,
         label,
@@ -318,18 +324,23 @@ const _singleTenantDb = async () => {
               label,
               async () => {
                 try {
-                  const lockId = `${label}`;
                   const couldAcquireLock = eventConfig.multiInstanceProcessing
                     ? true
-                    : await distributedLock.acquireLock(context, lockId, {
+                    : await distributedLock.acquireLock(context, label, {
                         expiryTime: eventQueueConfig.runInterval * 0.95,
                       });
                   if (!couldAcquireLock) {
                     return;
                   }
-                  await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
-                    skipWorkerPool: true,
-                  });
+                  await runEventCombinationForTenant(
+                    context,
+                    eventConfig.type,
+                    eventConfig.subType,
+                    openEvent.namespace,
+                    {
+                      skipWorkerPool: true,
+                    }
+                  );
                 } catch (err) {
                   cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
                 }
@@ -405,7 +416,7 @@ const _acquireRunId = async (context) => {
       overrideValue: true,
     });
   } else {
-    runId = await distributedLock.checkLockExistsAndReturnValue(context, EVENT_QUEUE_RUN_ID, {
+    runId = await distributedLock.getValue(context, EVENT_QUEUE_RUN_ID, {
       tenantScoped: false,
     });
   }
@@ -422,7 +433,7 @@ const _calculateOffsetForFirstRun = async () => {
   try {
     await trace(dummyContext, "calculateOffsetForFirstRun", async () => {
       if (eventQueueConfig.redisEnabled) {
-        let lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+        let lastRunTs = await distributedLock.getValue(dummyContext, EVENT_QUEUE_RUN_TS, {
           tenantScoped: false,
         });
         if (!lastRunTs) {
@@ -434,7 +445,7 @@ const _calculateOffsetForFirstRun = async () => {
           if (couldSetValue) {
             lastRunTs = ts;
           } else {
-            lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+            lastRunTs = await distributedLock.getValue(dummyContext, EVENT_QUEUE_RUN_TS, {
               tenantScoped: false,
             });
           }

package/src/runner/runnerHelper.js

@@ -12,12 +12,18 @@ const { trace } = require("../shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/runnerHelper";
 
-const runEventCombinationForTenant = async (context, type, subType, { skipWorkerPool, lockId, shouldTrace } = {}) => {
+const runEventCombinationForTenant = async (
+  context,
+  type,
+  subType,
+  namespace,
+  { skipWorkerPool, lockId, shouldTrace } = {}
+) => {
   try {
     if (skipWorkerPool) {
-      return await processEventQueue(context, type, subType);
+      return await processEventQueue(context, type, subType, namespace);
     } else {
-      const eventConfig = eventQueueConfig.getEventConfig(type, subType);
+      const eventConfig = eventQueueConfig.getEventConfig(type, subType, namespace);
       const label = `${type}_${subType}`;
       return await WorkerQueue.instance.addToQueue(
         eventConfig.load,
@@ -33,7 +39,7 @@ const runEventCombinationForTenant = async (context, type, subType, { skipWorker
               }
             }
 
-            await processEventQueue(context, type, subType);
+            await processEventQueue(context, type, subType, namespace);
           };
           if (shouldTrace) {
             return await trace(context, label, _exec, { newRootSpan: true });