@cap-js-community/event-queue 1.8.2 → 1.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "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",
   "types": "src/index.d.ts",

package/src/EventQueueProcessorBase.js

@@ -546,6 +546,16 @@ class EventQueueProcessorBase {
     });
   }
 
+  handleErrorTx(error) {
+    this.logger.error("Error in commit|rollback transaction, check handlers and constraints!", error, {
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
+    });
+    this.__queueEntries.forEach((queueEntry) => {
+      this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error);
+    });
+  }
+
   handleInvalidPayloadReturned(queueEntry) {
     this.logger.error(
       "Undefined payload is not allowed. If status should be done, nulls needs to be returned" +

package/src/config.js

@@ -58,7 +58,6 @@ class Config {
   #isEventQueueActive;
   #configFilePath;
   #processEventsAfterPublish;
-  #skipCsnCheck;
   #registerAsEventProcessor;
   #disableRedis;
   #env;
@@ -78,7 +77,8 @@ class Config {
   #cronTimezone;
   #publishEventBlockList;
   #crashOnRedisUnavailable;
-  #tenantIdFilterCb;
+  #tenantIdFilterTokenInfoCb;
+  #tenantIdFilterEventProcessingCb;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -94,7 +94,6 @@ class Config {
     this.#isEventQueueActive = true;
     this.#configFilePath = null;
     this.#processEventsAfterPublish = null;
-    this.#skipCsnCheck = null;
     this.#disableRedis = null;
     this.#env = getEnvInstance();
     this.#blockedEvents = {};
@@ -293,7 +292,10 @@ class Config {
 
   addCAPOutboxEvent(serviceName, config) {
     if (this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)]) {
-      return;
+      const index = this.#config.events.findIndex(
+        (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
+      );
+      this.#config.events.splice(index, 1);
     }
 
     const eventConfig = {
@@ -530,12 +532,20 @@ class Config {
     this.#crashOnRedisUnavailable = value;
   }
 
-  get tenantIdFilterCb() {
-    return this.#tenantIdFilterCb;
+  get tenantIdFilterTokenInfo() {
+    return this.#tenantIdFilterTokenInfoCb;
+  }
+
+  set tenantIdFilterTokenInfo(value) {
+    this.#tenantIdFilterTokenInfoCb = value;
+  }
+
+  get tenantIdFilterEventProcessing() {
+    return this.#tenantIdFilterEventProcessingCb;
   }
 
-  set tenantIdFilterCb(value) {
-    this.#tenantIdFilterCb = value;
+  set tenantIdFilterEventProcessing(value) {
+    this.#tenantIdFilterEventProcessingCb = value;
   }
 
   set globalTxTimeout(value) {
@@ -617,14 +627,6 @@ class Config {
     return this.#processEventsAfterPublish;
   }
 
-  set skipCsnCheck(value) {
-    this.#skipCsnCheck = value;
-  }
-
-  get skipCsnCheck() {
-    return this.#skipCsnCheck;
-  }
-
   set disableRedis(value) {
     this.#disableRedis = value;
   }

package/src/constants.js

@@ -21,7 +21,7 @@ module.exports = {
     VeryHigh: "veryHigh",
   },
   TenantIdCheckTypes: {
-    getAllTenantIds: "getAllTenantIds",
+    eventProcessing: "eventProcessing",
     getTokenInfo: "getTokenInfo",
   },
 };

package/src/index.d.ts

@@ -12,7 +12,7 @@ declare type EventProcessingStatusKeysType = keyof typeof EventProcessingStatus;
 export declare type EventProcessingStatusType = (typeof EventProcessingStatus)[EventProcessingStatusKeysType];
 
 export declare const TenantIdCheckTypes: {
-  getAllTenantIds: "getAllTenantIds";
+  eventProcessing: "eventProcessing";
   getTokenInfo: "getTokenInfo";
 };
 
@@ -182,54 +182,63 @@ export function triggerEventProcessingRedis(
 declare class Config {
   constructor();
 
-  getEventConfig(type: string, subType: string): any;
-  isCapOutboxEvent(type: string): boolean;
-  hasEventAfterCommitFlag(type: string, subType: string): boolean;
-  _checkRedisIsBound(): boolean;
-  checkRedisEnabled(): boolean;
-  publishEventBlockList(): boolean;
-  crashOnRedisUnavailable(): boolean;
+  getEventConfig(type: any, subType: any): any;
+  isCapOutboxEvent(type: any): boolean;
+  hasEventAfterCommitFlag(type: any, subType: any): any;
+  shouldBeProcessedInThisApplication(type: any, subType: any): boolean;
+  checkRedisEnabled(): any;
   attachConfigChangeHandler(): void;
   attachRedisUnsubscribeHandler(): void;
-  executeUnsubscribeHandlers(tenantId: string): void;
-  handleUnsubscribe(tenantId: string): void;
-  attachUnsubscribeHandler(cb: Function): void;
-  publishConfigChange(key: string, value: any): void;
-  blockEvent(type: string, subType: string, isPeriodic: boolean, tenant?: string): 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: string, subType: string, isPeriodic: boolean, tenant?: string): void;
-  addCAPOutboxEvent(serviceName: string, config: any): void;
-  isEventBlocked(type: string, subType: string, isPeriodicEvent: boolean, tenant: string): boolean;
-  get isEventQueueActive(): boolean;
+  unblockEvent(type: any, subType: any, isPeriodic: any, tenant?: string): void;
+  addCAPOutboxEvent(serviceName: any, config: any): void;
+  isEventBlocked(type: any, subType: any, isPeriodicEvent: any, tenant: any): any;
   set isEventQueueActive(value: boolean);
+  get isEventQueueActive(): boolean;
   set fileContent(config: any);
   get fileContent(): any;
-  get events(): any[];
-  get periodicEvents(): any[];
-  isPeriodicEvent(type: string, subType: string): boolean;
-  get allEvents(): any[];
-  get forUpdateTimeout(): number;
-  get globalTxTimeout(): number;
+  generateKey(type: any, subType: any): string;
+  removeEvent(type: any, subType: any): void;
+  isTenantUnsubscribed(tenantId: any): any;
+  get events(): any;
+  get periodicEvents(): any;
+  isPeriodicEvent(type: any, subType: any): any;
+  get allEvents(): any;
   set forUpdateTimeout(value: number);
+  get forUpdateTimeout(): number;
   set globalTxTimeout(value: number);
-  get runInterval(): number | null;
-  set runInterval(value: number);
-  get redisEnabled(): boolean | null;
-  set redisEnabled(value: boolean | null);
-  get initialized(): boolean;
+  get globalTxTimeout(): number;
+  set publishEventBlockList(value: any);
+  get publishEventBlockList(): any;
+  set crashOnRedisUnavailable(value: any);
+  get crashOnRedisUnavailable(): any;
+  set tenantIdFilterTokenInfo(value: any);
+  get tenantIdFilterTokenInfo(): any;
+  set tenantIdFilterEventProcessing(value: any);
+  get tenantIdFilterEventProcessing(): any;
+  set runInterval(value: any);
+  get runInterval(): any;
+  set redisEnabled(value: any);
+  get redisEnabled(): any;
   set initialized(value: boolean);
-  get instanceLoadLimit(): number;
+  get initialized(): boolean;
+  set cronTimezone(value: any);
+  get cronTimezone(): any;
   set instanceLoadLimit(value: number);
-  get isEventBlockedCb(): any;
+  get instanceLoadLimit(): number;
   set isEventBlockedCb(value: any);
+  get isEventBlockedCb(): any;
   get tableNameEventQueue(): string;
   get tableNameEventLock(): string;
-  set configFilePath(value: string | null);
-  get configFilePath(): string | null;
+  set configFilePath(value: any);
+  get configFilePath(): any;
   set processEventsAfterPublish(value: any);
   get processEventsAfterPublish(): any;
-  set skipCsnCheck(value: any);
-  get skipCsnCheck(): any;
   set disableRedis(value: any);
   get disableRedis(): any;
   set updatePeriodicEvents(value: any);
@@ -248,6 +257,8 @@ declare class Config {
   get redisOptions(): any;
   set insertEventsBeforeCommit(value: any);
   get insertEventsBeforeCommit(): any;
+  set enableCAPTelemetry(value: any);
+  get enableCAPTelemetry(): any;
   get isMultiTenancy(): boolean;
 }
 

package/src/initialize.js

@@ -10,7 +10,7 @@ const VError = require("verror");
 const runner = require("./runner/runner");
 const dbHandler = require("./dbHandler");
 const config = require("./config");
-const { initEventQueueRedisSubscribe, closeSubscribeClient } = require("./redis/redisSub");
+const redisSub = require("./redis/redisSub");
 const redis = require("./shared/redis");
 const eventQueueAsOutbox = require("./outbox/eventQueueAsOutbox");
 const { getAllTenantIds } = require("./shared/cdsHelper");
@@ -22,6 +22,7 @@ const readFileAsync = promisify(fs.readFile);
 
 const VERROR_CLUSTER_NAME = "EventQueueInitialization";
 const COMPONENT = "eventQueue/initialize";
+const TIMEOUT_SHUTDOWN = 2500;
 
 const CONFIG_VARS = [
   ["configFilePath", null],
@@ -41,7 +42,6 @@ const CONFIG_VARS = [
   ["cronTimezone", null],
   ["publishEventBlockList", true],
   ["crashOnRedisUnavailable", false],
-  ["tenantIdFilterCb", null],
 ];
 
 /**
@@ -65,7 +65,6 @@ const CONFIG_VARS = [
  * @param {string} [options.cronTimezone=null] - Default timezone for cron jobs.
  * @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 {function} [options.tenantIdFilterCb=null] - Allows to set customer filter function to filter the tenants ids which should be processed in the event-queue
  */
 const initialize = async (options = {}) => {
   if (config.initialized) {
@@ -148,7 +147,7 @@ const registerEventProcessors = () => {
   const errorHandler = (err) => cds.log(COMPONENT).error("error during init runner", err);
 
   if (config.redisEnabled) {
-    initEventQueueRedisSubscribe();
+    redisSub.initEventQueueRedisSubscribe();
     config.attachConfigChangeHandler();
     if (config.isMultiTenancy) {
       runner.multiTenancyRedis().catch(errorHandler);
@@ -186,9 +185,24 @@ const mixConfigVarsWithEnv = (options) => {
 };
 
 const registerCdsShutdown = () => {
+  const isTestProfile = cds.env.profiles.find((profile) => profile.includes("test"));
+  if (isTestProfile || !config.redisEnabled) {
+    return;
+  }
   cds.on("shutdown", async () => {
-    await distributedLock.shutdownHandler();
-    await Promise.allSettled([redis.closeMainClient(), closeSubscribeClient()]);
+    return await new Promise((resolve) => {
+      const 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([redis.closeMainClient(), redis.closeSubscribeClient()]).then((result) => {
+          clearTimeout(timeoutRef);
+          resolve(result);
+        })
+      );
+    });
   });
 };
 

package/src/outbox/eventQueueAsOutbox.js

@@ -12,7 +12,13 @@ const COMPONENT_NAME = "/eventQueue/eventQueueAsOutbox";
 const EVENT_QUEUE_SPECIFIC_FIELDS = ["startAfter", "referenceEntity", "referenceEntityKey"];
 
 function outboxed(srv, customOpts) {
-  // outbox max. once
+  if (!(new.target || customOpts)) {
+    const former = srv[OUTBOXED];
+    if (former) {
+      return former;
+    }
+  }
+
   const logger = cds.log(COMPONENT_NAME);
   const outboxOpts = Object.assign(
     {},
@@ -21,14 +27,8 @@ function outboxed(srv, customOpts) {
     customOpts || {}
   );
 
-  if (!new.target) {
-    const former = srv[OUTBOXED];
-    if (former) {
-      if (outboxOpts.kind === "persistent-outbox") {
-        config.addCAPOutboxEvent(srv.name, outboxOpts);
-      }
-      return former;
-    }
+  if (outboxOpts.kind === "persistent-outbox") {
+    config.addCAPOutboxEvent(srv.name, outboxOpts);
   }
 
   const originalSrv = srv[UNBOXED] || srv;
@@ -36,11 +36,9 @@ function outboxed(srv, customOpts) {
   outboxedSrv[UNBOXED] = originalSrv;
 
   if (!new.target) {
-    Object.defineProperty(srv, OUTBOXED, { value: outboxedSrv });
-  }
-
-  if (outboxOpts.kind === "persistent-outbox") {
-    config.addCAPOutboxEvent(srv.name, outboxOpts);
+    if (!srv[OUTBOXED]) {
+      Object.defineProperty(srv, OUTBOXED, { value: outboxedSrv });
+    }
   }
   outboxedSrv.handle = async function (req) {
     const context = req.context || cds.context;

package/src/processEventQueue.js

@@ -201,56 +201,67 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
   }
 };
 
-const processEventMap = async (eventTypeInstance) => {
-  eventTypeInstance.startPerformanceTracerEvents();
-  await eventTypeInstance.beforeProcessingEvents();
-  eventTypeInstance.logStartMessage();
-  if (eventTypeInstance.commitOnEventLevel) {
-    eventTypeInstance.txUsageAllowed = false;
+const processEventMap = async (instance) => {
+  instance.startPerformanceTracerEvents();
+  await instance.beforeProcessingEvents();
+  instance.logStartMessage();
+  if (instance.commitOnEventLevel) {
+    instance.txUsageAllowed = false;
   }
   await limiter(
-    eventTypeInstance.parallelEventProcessing,
-    Object.entries(eventTypeInstance.eventProcessingMap),
+    instance.parallelEventProcessing,
+    Object.entries(instance.eventProcessingMap),
     async ([key, { queueEntries, payload }]) => {
-      if (eventTypeInstance.commitOnEventLevel) {
+      if (instance.commitOnEventLevel) {
         let statusMap;
         await executeInNewTransaction(
-          eventTypeInstance.baseContext,
-          `eventQueue-processEvent-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+          instance.baseContext,
+          `eventQueue-processEvent-${instance.eventType}##${instance.eventSubType}`,
           async (tx) => {
-            statusMap = await _processEvent(eventTypeInstance, tx.context, key, queueEntries, payload);
-            if (
-              eventTypeInstance.statusMapContainsError(statusMap) ||
-              eventTypeInstance.shouldRollbackTransaction(key)
-            ) {
+            statusMap = await _processEvent(instance, tx.context, key, queueEntries, payload);
+            const shouldRollback =
+              instance.statusMapContainsError(statusMap) || instance.shouldRollbackTransaction(key);
+            if (shouldRollback) {
               await tx.rollback();
+              await _commitStatusInNewTx(instance, statusMap);
+            } else {
+              await instance.persistEventStatus(tx, {
+                skipChecks: true,
+                statusMap,
+              });
             }
           }
         );
-        await executeInNewTransaction(
-          eventTypeInstance.baseContext,
-          `eventQueue-persistStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
-          async (tx) => {
-            eventTypeInstance.processEventContext = tx.context;
-            await eventTypeInstance.persistEventStatus(tx, {
-              skipChecks: true,
-              statusMap,
-            });
-          }
-        );
       } else {
-        await _processEvent(eventTypeInstance, eventTypeInstance.context, key, queueEntries, payload);
+        await _processEvent(instance, instance.context, key, queueEntries, payload);
       }
     }
-  ).finally(() => {
-    eventTypeInstance.clearEventProcessingContext();
-    if (eventTypeInstance.commitOnEventLevel) {
-      eventTypeInstance.txUsageAllowed = true;
-    }
-  });
-  eventTypeInstance.endPerformanceTracerEvents();
+  )
+    .catch((err) => {
+      instance.handleErrorTx(err);
+    })
+    .finally(() => {
+      instance.clearEventProcessingContext();
+      if (instance.commitOnEventLevel) {
+        instance.txUsageAllowed = true;
+      }
+    });
+  instance.endPerformanceTracerEvents();
 };
 
+const _commitStatusInNewTx = async (eventTypeInstance, statusMap) =>
+  await executeInNewTransaction(
+    eventTypeInstance.baseContext,
+    `eventQueue-persistStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+    async (tx) => {
+      eventTypeInstance.processEventContext = tx.context;
+      await eventTypeInstance.persistEventStatus(tx, {
+        skipChecks: true,
+        statusMap,
+      });
+    }
+  );
+
 const _checkEventIsBlocked = async (baseInstance) => {
   const isEventBlockedCb = config.isEventBlockedCb;
   let eventBlocked;

package/src/redis/redisPub.js

@@ -10,6 +10,7 @@ const config = require("../config");
 const common = require("../shared/common");
 const { runEventCombinationForTenant } = require("../runner/runnerHelper");
 const trace = require("../shared/openTelemetry");
+const { TenantIdCheckTypes } = require("../constants");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/redisPub";
@@ -59,6 +60,10 @@ const broadcastEvent = async (tenantId, events, forceBroadcast = false) => {
   events = Array.isArray(events) ? events : [events];
   try {
     if (!config.redisEnabled) {
+      const tenantShouldBeProcessed = await common.isTenantIdValidCb(TenantIdCheckTypes.eventProcessing, tenantId);
+      if (!tenantShouldBeProcessed) {
+        return;
+      }
       await _processLocalWithoutRedis(tenantId, events);
       return;
     }
@@ -66,6 +71,9 @@ const broadcastEvent = async (tenantId, events, forceBroadcast = false) => {
       await trace(context, "broadcast-inserted-events", async () => {
         for (const { type, subType } of events) {
           const eventConfig = config.getEventConfig(type, subType);
+          if (!eventConfig) {
+            continue;
+          }
           for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
             const result = eventConfig.multiInstanceProcessing
               ? false

package/src/redis/redisSub.js

@@ -6,15 +6,16 @@ const redis = require("../shared/redis");
 const config = require("../config");
 const runnerHelper = require("../runner/runnerHelper");
 const common = require("../shared/common");
+const { TenantIdCheckTypes } = require("../constants");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/redisSub";
-let subscriberClientPromise;
 
 const initEventQueueRedisSubscribe = () => {
-  if (subscriberClientPromise || !config.redisEnabled) {
+  if (initEventQueueRedisSubscribe._initDone || !config.redisEnabled) {
     return;
   }
+  initEventQueueRedisSubscribe._initDone = true;
   redis.subscribeRedisChannel(config.redisOptions, EVENT_MESSAGE_CHANNEL, _messageHandlerProcessEvents);
 };
 
@@ -22,6 +23,10 @@ const _messageHandlerProcessEvents = async (messageData) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
     const { lockId, tenantId, type, subType } = JSON.parse(messageData);
+    const tenantShouldBeProcessed = await common.isTenantIdValidCb(TenantIdCheckTypes.eventProcessing, tenantId);
+    if (!tenantShouldBeProcessed) {
+      return;
+    }
     logger.debug("received redis event", {
       tenantId,
       type,
@@ -83,20 +88,8 @@ const _messageHandlerProcessEvents = async (messageData) => {
   }
 };
 
-const closeSubscribeClient = async () => {
-  try {
-    const client = await subscriberClientPromise;
-    if (client?.quit) {
-      await client.quit();
-    }
-  } catch (err) {
-    // ignore errors during shutdown
-  }
-};
-
 module.exports = {
   initEventQueueRedisSubscribe,
-  closeSubscribeClient,
   __: {
     _messageHandlerProcessEvents,
   },

package/src/runner/runner.js

@@ -111,17 +111,19 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
     // NOTE: do checks for all tenants on the same app instance --> acquire lock tenant independent
     //       distribute from this instance to all others
     const dummyContext = new cds.EventContext({});
-    const couldAcquireLock = await trace(
-      dummyContext,
-      "acquire-lock-master-runner",
-      async () => {
-        return await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_RUN_REDIS_CHECK, {
-          expiryTime: eventQueueConfig.runInterval * 0.95,
-          tenantScoped: false,
-        });
-      },
-      { newRootSpan: true }
-    );
+    const couldAcquireLock = config.tenantIdFilterEventProcessing
+      ? true
+      : await trace(
+          dummyContext,
+          "acquire-lock-master-runner",
+          async () => {
+            return await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_RUN_REDIS_CHECK, {
+              expiryTime: eventQueueConfig.runInterval * 0.95,
+              tenantScoped: false,
+            });
+          },
+          { newRootSpan: true }
+        );
     if (!couldAcquireLock) {
       return;
     }
@@ -237,7 +239,7 @@ const _executePeriodicEventsAllTenants = async (tenantIds) => {
       };
       await cds.tx(tenantContext, async ({ context }) => {
         await trace(tenantContext, "update-periodic-events-for-tenant", async () => {
-          if (!config.redisEnabled) {
+          if (!config.redisEnabled && !config.tenantIdFilterEventProcessing) {
             const couldAcquireLock = await distributedLock.acquireLock(context, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
               expiryTime: eventQueueConfig.runInterval * 0.95,
             });
@@ -433,7 +435,7 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
       dummyContext,
       "update-periodic-events",
       async () => {
-        if (config.redisEnabled) {
+        if (config.redisEnabled && !config.tenantIdFilterEventProcessing) {
           const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
             expiryTime: 60 * 1000, // short living lock --> assume we do not have 2 onboards within 1 minute
             tenantScoped: false,

package/src/shared/cdsHelper.js

@@ -23,6 +23,7 @@ const COMPONENT_NAME = "/eventQueue/cdsHelper";
 async function executeInNewTransaction(context = {}, transactionTag, fn, args, { info = {} } = {}) {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
+  let transactionRollbackPromise = Promise.resolve(false);
   try {
     const user = new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(context.tenant) });
     if (cds.db.kind === "hana") {
@@ -36,7 +37,15 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
         },
         async (tx) => {
           tx.context._ = context._ ?? {};
-          return await fn(tx, ...parameters);
+          return new Promise((outerResolve, outerReject) => {
+            transactionRollbackPromise = new Promise((resolve) => {
+              tx.context.on("succeeded", () => resolve(false));
+              tx.context.on("failed", () => resolve(true));
+              fn(tx, ...parameters)
+                .then(outerResolve)
+                .catch(outerReject);
+            });
+          });
         }
       );
     } else {
@@ -51,7 +60,10 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
             user,
             headers: context.headers,
           },
-          async (tx) => fn(tx, ...parameters)
+          async (tx) => {
+            await fn(tx, ...parameters);
+            transactionRollbackPromise = false;
+          }
         );
       } else {
         contextTx.context.user = user;
@@ -68,17 +80,24 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
           // change rollback to no opt - closing tx would cause follow-up usage to fail.
           // the process that opened the tx needs to manage it
         };
-        await fn(contextTx, ...parameters).finally(() => (contextTx.rollback = txRollback));
+        await fn(contextTx, ...parameters)
+          .then(() => (transactionRollbackPromise = false))
+          .finally(() => (contextTx.rollback = txRollback));
       }
     }
   } catch (err) {
+    const transactionRollback = await transactionRollbackPromise;
     if (err instanceof VError) {
       Object.assign(err.jse_info, {
         newTx: info,
       });
-      throw err;
+      if (transactionRollback) {
+        throw err;
+      } else {
+        logger.error("business transaction commited but succeeded|done|failed threw a error!", err);
+      }
     } else {
-      throw new VError(
+      const nestedError = new VError(
         {
           name: VERROR_CLUSTER_NAME,
           cause: err,
@@ -86,6 +105,11 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
         },
         "Execution in new transaction failed"
       );
+      if (transactionRollback) {
+        throw err;
+      } else {
+        logger.error("business transaction commited but succeeded|done|failed threw a error!", nestedError);
+      }
     }
   } finally {
     logger.debug("Execution in new transaction finished", info);
@@ -109,7 +133,13 @@ const getAllTenantIds = async () => {
   const response = await ssp.get("/tenant");
   return response
     .map((tenant) => tenant.subscribedTenantId ?? tenant.tenant)
-    .filter((tenantId) => common.isTenantIdValidCb(TenantIdCheckTypes.getAllTenantIds, tenantId));
+    .reduce(async (result, tenantId) => {
+      result = await result;
+      if (await common.isTenantIdValidCb(TenantIdCheckTypes.eventProcessing, tenantId)) {
+        result.push(tenantId);
+      }
+      return result;
+    }, []);
 };
 
 module.exports = {

package/src/shared/common.js

@@ -4,6 +4,8 @@ const crypto = require("crypto");
 
 const cds = require("@sap/cds");
 const xssec = require("@sap/xssec");
+const VError = require("verror");
+
 const config = require("../config");
 const { TenantIdCheckTypes } = require("../constants");
 
@@ -44,7 +46,22 @@ const limiter = async (limit, payloads, iterator) => {
       }
     }
   }
-  return Promise.allSettled(returnPromises);
+  return promiseAllDone(returnPromises);
+};
+
+const promiseAllDone = async (iterable) => {
+  const results = await Promise.allSettled(iterable);
+  const rejects = results.filter((entry) => {
+    return entry.status === "rejected";
+  });
+  if (rejects.length === 1) {
+    return Promise.reject(rejects[0].reason);
+  } else if (rejects.length > 1) {
+    return Promise.reject(new VError.MultiError(rejects.map((reject) => reject.reason)));
+  }
+  return results.map((entry) => {
+    return entry.value;
+  });
 };
 
 const isValidDate = (value) => {
@@ -115,10 +132,23 @@ const getTokenInfo = async (tenantId) => {
   return await tokenInfoCache[tenantId].value;
 };
 
-const isTenantIdValidCb = (checkType, tenantId) => {
-  if (config.tenantIdFilterCb) {
-    return config.tenantIdFilterCb(checkType, tenantId);
-  } else {
+const isTenantIdValidCb = async (checkType, tenantId) => {
+  let cb;
+  switch (checkType) {
+    case TenantIdCheckTypes.getTokenInfo:
+      cb = config.tenantIdFilterTokenInfo;
+      break;
+    case TenantIdCheckTypes.eventProcessing:
+      cb = config.tenantIdFilterEventProcessing;
+      break;
+    default:
+      cb = async () => true;
+  }
+
+  try {
+    return cb ? await cb(tenantId) : true;
+  } catch (err) {
+    cds.log(COMPONENT_NAME).error("failed in custom tenant id filter callback. Returning true.", err);
     return true;
   }
 };
@@ -131,6 +161,7 @@ module.exports = {
   hashStringTo32Bit,
   getTokenInfo,
   isTenantIdValidCb,
+  promiseAllDone,
   __: {
     clearTokenInfoCache: () => (getTokenInfo._tokenInfoCache = {}),
   },

package/src/shared/env.js

@@ -18,7 +18,7 @@ class Env {
   }
 
   get redisRequires() {
-    return cds.requires["redis-eventQueue"] ?? cds.requires["redis"];
+    return cds.requires["redis-eventQueue"] || cds.requires["redis"];
   }
 
   get applicationName() {

package/src/shared/redis.js

@@ -9,7 +9,8 @@ const COMPONENT_NAME = "/eventQueue/shared/redis";
 const LOG_AFTER_SEC = 5;
 
 let mainClientPromise;
-const subscriberChannelClientPromise = {};
+let subscriberClientPromise;
+const subscribedChannels = {};
 let lastErrorLog = Date.now();
 
 const createMainClientAndConnect = (options) => {
@@ -18,7 +19,8 @@ const createMainClientAndConnect = (options) => {
   }
 
   const errorHandlerCreateClient = (err) => {
-    cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
+    mainClientPromise?.then?.(_resilientClientClose);
+    cds.log(COMPONENT_NAME).error("error from redis main client:", err);
     mainClientPromise = null;
     setTimeout(() => createMainClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
   };
@@ -63,7 +65,7 @@ const createClientAndConnect = async (options, errorHandlerCreateClient, isConne
       client.on("error", (err) => {
         const dateNow = Date.now();
         if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
-          cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
+          cds.log(COMPONENT_NAME).error("error redis client:", err);
           lastErrorLog = dateNow;
         }
       });
@@ -84,21 +86,48 @@ const createClientAndConnect = async (options, errorHandlerCreateClient, isConne
 };
 
 const subscribeRedisChannel = (options, channel, subscribeHandler) => {
+  subscribedChannels[channel] = subscribeHandler;
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error(`error from redis client for pub/sub failed for channel ${channel}`, err);
-    subscriberChannelClientPromise[channel] = null;
-    setTimeout(() => subscribeRedisChannel(options, channel, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
+    subscriberClientPromise?.then?.(_resilientClientClose);
+    subscriberClientPromise = null;
+    setTimeout(() => _subscribeChannels(options, subscribedChannels, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
   };
 
-  subscriberChannelClientPromise[channel] = createClientAndConnect(options, errorHandlerCreateClient)
+  _subscribeChannels(options, { [channel]: subscribeHandler }, errorHandlerCreateClient);
+};
+
+const _subscribeChannels = (options, subscribedChannels, errorHandlerCreateClient) => {
+  subscriberClientPromise = createClientAndConnect(options, errorHandlerCreateClient)
     .then((client) => {
-      cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });
-      client.subscribe(channel, subscribeHandler).catch(errorHandlerCreateClient);
+      for (const channel in subscribedChannels) {
+        const fn = subscribedChannels[channel];
+        client._subscribedChannels ??= {};
+        if (client._subscribedChannels[channel]) {
+          continue;
+        }
+        cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });
+        client
+          .subscribe(channel, fn)
+          .then(() => {
+            client._subscribedChannels ??= {};
+            client._subscribedChannels[channel] = 1;
+          })
+          .catch(() => {
+            cds.log(COMPONENT_NAME).error("error subscribe to channel - retrying...");
+            setTimeout(() => _subscribeChannels(options, [channel], fn), LOG_AFTER_SEC * 1000).unref();
+          });
+      }
     })
     .catch((err) => {
       cds
         .log(COMPONENT_NAME)
-        .error(`error from redis client for pub/sub failed during startup - trying to reconnect - ${channel}`, err);
+        .error(
+          `error from redis client for pub/sub failed during startup - trying to reconnect - ${Object.keys(
+            subscribedChannels
+          ).join(", ")}`,
+          err
+        );
     });
 };
 
@@ -108,11 +137,13 @@ const publishMessage = async (options, channel, message) => {
 };
 
 const closeMainClient = async () => {
-  try {
-    await _resilientClientClose(await mainClientPromise);
-  } catch (err) {
-    // ignore errors during shutdown
-  }
+  await _resilientClientClose(await mainClientPromise);
+  cds.log(COMPONENT_NAME).info("main redis client closed!");
+};
+
+const closeSubscribeClient = async () => {
+  await _resilientClientClose(await subscriberClientPromise);
+  cds.log(COMPONENT_NAME).info("subscribe redis client closed!");
 };
 
 const _resilientClientClose = async (client) => {
@@ -121,7 +152,7 @@ const _resilientClientClose = async (client) => {
       await client.quit();
     }
   } catch (err) {
-    // ignore errors during shutdown
+    cds.log(COMPONENT_NAME).info("error during redis close - continuing...", err);
   }
 };
 
@@ -151,5 +182,6 @@ module.exports = {
   subscribeRedisChannel,
   publishMessage,
   closeMainClient,
+  closeSubscribeClient,
   connectionCheck,
 };