@cap-js-community/event-queue 1.7.2 → 1.7.4

package/cds-plugin.js

@@ -4,6 +4,7 @@ const cds = require("@sap/cds");
 const cdsPackage = require("@sap/cds/package.json");
 
 const eventQueue = require("./src");
+const EventQueueError = require("./src/EventQueueError");
 const COMPONENT_NAME = "/eventQueue/plugin";
 const SERVE_COMMAND = "serve";
 
@@ -18,5 +19,10 @@ if ((doLegacyBuildDetection && isBuild) || (!doLegacyBuildDetection && !isServe)
 }
 
 if (Object.keys(cds.env.eventQueue ?? {}).length) {
-  module.exports = eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
+  module.exports = eventQueue.initialize().catch((err) => {
+    if (EventQueueError.isRedisConnectionFailure(err) && eventQueue.config.crashOnRedisUnavailable) {
+      throw err;
+    }
+    cds.log(COMPONENT_NAME).error(err);
+  });
 }

package/db/Event.cds

@@ -9,6 +9,7 @@ type Status: Integer enum {
     Done = 2;
     Error = 3;
     Exceeded = 4;
+    Suspended = 5;
 }
 
 entity Event: cuid {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.7.2",
+  "version": "1.7.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",
@@ -47,13 +47,13 @@
     "cron-parser": "^4.9.0",
     "redis": "^4.7.0",
     "verror": "^1.10.1",
-    "yaml": "^2.5.1"
+    "yaml": "^2.6.1"
   },
   "devDependencies": {
     "@cap-js/hana": "^1.3.0",
     "@cap-js/sqlite": "^1.7.3",
-    "@sap/cds": "^8.3.0",
-    "@sap/cds-dk": "^8.3.0",
+    "@sap/cds": "^8.4.2",
+    "@sap/cds-dk": "^8.4.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",

package/src/EventQueueError.js

@@ -41,7 +41,7 @@ const ERROR_CODES_META = {
     message: "error during create client with redis-cache service",
   },
   [ERROR_CODES.REDIS_LOCAL_NO_RECONNECT]: {
-    message: "disabled reconnect, because we are not running on cloud foundry",
+    message: "disabled reconnect, because not running on cloud foundry",
   },
   [ERROR_CODES.MISSING_TABLE_DEFINITION]: {
     message: "Could not find table in csn. Make sure the provided table name is correct and the table is known by CDS.",
@@ -135,7 +135,7 @@ class EventQueueError extends VError {
     return new EventQueueError(
       {
         name: ERROR_CODES.REDIS_CREATE_CLIENT,
-        cause: err,
+        ...(err && { cause: err }),
       },
       message
     );
@@ -325,6 +325,10 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static isRedisConnectionFailure(err) {
+    return err instanceof VError && err.name === ERROR_CODES.REDIS_CREATE_CLIENT;
+  }
 }
 
 module.exports = EventQueueError;

package/src/config.js

@@ -77,6 +77,8 @@ class Config {
   #unsubscribedTenants = {};
   #cronTimezone;
   #publishEventBlockList;
+  #crashOnRedisUnavailable;
+  #tenantIdFilterCb;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -510,6 +512,22 @@ class Config {
     this.#publishEventBlockList = value;
   }
 
+  get crashOnRedisUnavailable() {
+    return this.#crashOnRedisUnavailable;
+  }
+
+  set crashOnRedisUnavailable(value) {
+    this.#crashOnRedisUnavailable = value;
+  }
+
+  get tenantIdFilterCb() {
+    return this.#tenantIdFilterCb;
+  }
+
+  set tenantIdFilterCb(value) {
+    this.#tenantIdFilterCb = value;
+  }
+
   set globalTxTimeout(value) {
     this.#globalTxTimeout = value;
   }

package/src/constants.js

@@ -7,6 +7,7 @@ module.exports = {
     Done: 2,
     Error: 3,
     Exceeded: 4,
+    Suspended: 5,
   },
   TransactionMode: {
     isolated: "isolated",
@@ -19,4 +20,8 @@ module.exports = {
     High: "high",
     VeryHigh: "veryHigh",
   },
+  TenantIdCheckTypes: {
+    getAllTenantIds: "getAllTenantIds",
+    getTokenInfo: "getTokenInfo",
+  },
 };

package/src/index.d.ts

@@ -182,6 +182,8 @@ declare class Config {
   hasEventAfterCommitFlag(type: string, subType: string): boolean;
   _checkRedisIsBound(): boolean;
   checkRedisEnabled(): boolean;
+  publishEventBlockList(): boolean;
+  crashOnRedisUnavailable(): boolean;
   attachConfigChangeHandler(): void;
   attachRedisUnsubscribeHandler(): void;
   executeUnsubscribeHandlers(tenantId: string): void;

package/src/initialize.js

@@ -16,6 +16,7 @@ const eventQueueAsOutbox = require("./outbox/eventQueueAsOutbox");
 const { getAllTenantIds } = require("./shared/cdsHelper");
 const { EventProcessingStatus } = require("./constants");
 const distributedLock = require("./shared/distributedLock");
+const EventQueueError = require("./EventQueueError");
 
 const readFileAsync = promisify(fs.readFile);
 
@@ -39,6 +40,8 @@ const CONFIG_VARS = [
   ["enableCAPTelemetry", false],
   ["cronTimezone", null],
   ["publishEventBlockList", true],
+  ["crashOnRedisUnavailable", false],
+  ["tenantIdFilterCb", null],
 ];
 
 /**
@@ -61,6 +64,8 @@ const CONFIG_VARS = [
  * @param {boolean} [options.enableCAPTelemetry=false] - Enable telemetry for CAP.
  * @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) {
@@ -89,6 +94,9 @@ const initialize = async (options = {}) => {
   });
   if (redisEnabled) {
     config.redisEnabled = await redis.connectionCheck(config.redisOptions);
+    if (!config.redisEnabled && config.crashOnRedisUnavailable) {
+      throw EventQueueError.redisConnectionFailure();
+    }
   }
   config.fileContent = await readConfigFromFile(config.configFilePath);
 
@@ -139,17 +147,21 @@ const registerEventProcessors = () => {
 
   const errorHandler = (err) => cds.log(COMPONENT).error("error during init runner", err);
 
-  if (!config.isMultiTenancy) {
-    runner.singleTenant().catch(errorHandler);
-    return;
-  }
-
   if (config.redisEnabled) {
     initEventQueueRedisSubscribe();
     config.attachConfigChangeHandler();
-    runner.multiTenancyRedis().catch(errorHandler);
-  } else {
+    if (config.isMultiTenancy) {
+      runner.multiTenancyRedis().catch(errorHandler);
+    } else {
+      runner.singleTenantRedis().catch(errorHandler);
+    }
+    return;
+  }
+
+  if (config.isMultiTenancy) {
     runner.multiTenancyDb().catch(errorHandler);
+  } else {
+    runner.singleTenantDb().catch(errorHandler);
   }
 };
 

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -27,7 +27,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       delete msg.contextUser;
       processContext.user = new cds.User.Privileged({
         id: userId,
-        authInfo: await common.getAuthInfo(processContext.tenant),
+        authInfo: await common.getTokenInfo(processContext.tenant),
       });
       processContext._eventQueue = { processor: this, key, queueEntries, payload };
       await cds.unboxed(service).tx(processContext)[invocationFn](msg);

package/src/redis/redisPub.js

@@ -109,7 +109,7 @@ const _processLocalWithoutRedis = async (tenantId, events) => {
     let context = {};
     if (tenantId) {
       const user = await cds.tx({ tenant: tenantId }, async () => {
-        return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+        return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
       });
       context = {
         tenant: tenantId,

package/src/redis/redisSub.js

@@ -41,14 +41,14 @@ const _messageHandlerProcessEvents = async (messageData) => {
           const service = await cds.connect.to(subType);
           cds.outboxed(service);
         } catch (err) {
-          logger.error("could not connect to outboxed service", err, {
+          logger.warn("could not connect to outboxed service", err, {
             type,
             subType,
           });
           return;
         }
       } else {
-        logger.error("cannot find configuration for published event. Event won't be processed", {
+        logger.warn("cannot find configuration for published event. Event won't be processed", {
           type,
           subType,
         });
@@ -66,7 +66,7 @@ const _messageHandlerProcessEvents = async (messageData) => {
     }
 
     const user = await cds.tx({ tenant: tenantId }, async () => {
-      return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+      return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
     });
     const tenantContext = {
       tenant: tenantId,

package/src/runner/openEvents.js

@@ -5,6 +5,8 @@ const cds = require("@sap/cds");
 const eventConfig = require("../config");
 const { EventProcessingStatus } = require("../constants");
 
+const MS_IN_DAYS = 24 * 60 * 60 * 1000;
+
 const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const startTime = new Date();
   const refDateStartAfter = new Date(startTime.getTime() + eventConfig.runInterval * 1.2);
@@ -21,7 +23,11 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
         EventProcessingStatus.InProgress,
         "AND lastAttemptTimestamp <=",
         new Date(startTime.getTime() - eventConfig.globalTxTimeout).toISOString(),
-        ") )"
+        ") ) AND (createdAt >=",
+        new Date(startTime.getTime() - 30 * MS_IN_DAYS).toISOString(),
+        " OR startAfter >=",
+        new Date(startTime.getTime() - 30 * MS_IN_DAYS).toISOString(),
+        ")"
       )
       .columns("type", "subType")
       .groupBy("type", "subType")
@@ -30,9 +36,13 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const result = [];
   for (const { type, subType } of entries) {
     if (eventConfig.isCapOutboxEvent(type)) {
-      await cds.connect
+      cds.connect
         .to(subType)
         .then((service) => {
+          if (!filterAppSpecificEvents) {
+            return; // will be done in finally
+          }
+
           if (!service) {
             return;
           }
@@ -45,7 +55,12 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
             result.push({ type, subType });
           }
         })
-        .catch(() => {});
+        .catch(() => {})
+        .finally(() => {
+          if (!filterAppSpecificEvents) {
+            result.push({ type, subType });
+          }
+        });
     } else {
       if (filterAppSpecificEvents) {
         if (
@@ -55,7 +70,7 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
           result.push({ type, subType });
         }
       } else {
-        eventConfig.getEventConfig(type, subType) && result.push({ type, subType });
+        result.push({ type, subType });
       }
     }
   }

package/src/runner/runner.js

@@ -27,12 +27,14 @@ let OFFSET_FIRST_RUN = 10 * 1000;
 let tenantIdHash;
 let singleRunDone;
 
-const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantDb);
+const singleTenantDb = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantDb);
 
 const multiTenancyDb = () => _scheduleFunction(async () => {}, _multiTenancyDb);
 
 const multiTenancyRedis = () => _scheduleFunction(async () => {}, _multiTenancyRedis);
 
+const singleTenantRedis = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantRedis);
+
 const _scheduleFunction = async (singleRunFn, periodicFn) => {
   const logger = cds.log(COMPONENT_NAME);
   const eventsForAutomaticRun = eventQueueConfig.allEvents;
@@ -132,7 +134,7 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
           async () => {
             tx.context.user = new cds.User.Privileged({
               id: config.userId,
-              authInfo: await common.getAuthInfo(tenantId),
+              authInfo: await common.getTokenInfo(tenantId),
             });
             const entries = await openEvents.getOpenQueueEntries(tx, false);
             logger.info("broadcasting events for run", {
@@ -166,10 +168,10 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
     let tenantContext;
     const events = await trace(
       { id, tenant: tenantId },
-      "fetch-openEvents-and-authInfo",
+      "fetch-openEvents-and-tokenInfo",
       async () => {
         const user = await cds.tx({ tenant: tenantId }, async () => {
-          return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+          return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
         });
         tenantContext = {
           tenant: tenantId,
@@ -227,7 +229,7 @@ const _executePeriodicEventsAllTenants = async (tenantIds) => {
   for (const tenantId of tenantIds) {
     try {
       const user = await cds.tx({ tenant: tenantId }, async () => {
-        return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+        return new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(tenantId) });
       });
       const tenantContext = {
         tenant: tenantId,
@@ -258,7 +260,7 @@ const _singleTenantDb = async () => {
   const id = cds.utils.uuid();
   const events = await trace(
     { id },
-    "fetch-openEvents-and-authInfo",
+    "fetch-openEvents-and-tokenInfo",
     async () => {
       return await cds.tx({}, async (tx) => {
         return await openEvents.getOpenQueueEntries(tx);
@@ -300,6 +302,54 @@ const _singleTenantDb = async () => {
   );
 };
 
+const _singleTenantRedis = async () => {
+  const id = cds.utils.uuid();
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    // NOTE: do checks for open events on one app instance 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 }
+    );
+    if (!couldAcquireLock) {
+      return;
+    }
+
+    await trace(
+      { id },
+      "get-openEvents-and-publish",
+      async () => {
+        return await cds.tx({}, async (tx) => {
+          const entries = await openEvents.getOpenQueueEntries(tx, false);
+          logger.info("broadcasting events for run", {
+            entries: entries.length,
+          });
+          if (!entries.length) {
+            return;
+          }
+          // Do not wait until this is finished - as broadcastEvent has a retry mechanism and can delay this loop
+          redisPub.broadcastEvent(null, entries).catch((err) => {
+            logger.error("broadcasting event failed", err, {
+              entries: entries.length,
+            });
+          });
+        });
+      },
+      { newRootSpan: true }
+    );
+  } catch (err) {
+    logger.info("executing event queue run for single tenant via redis", err);
+  }
+};
+
 const _acquireRunId = async (context) => {
   let runId = randomUUID();
   const couldSetValue = await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_ID, runId, {
@@ -401,9 +451,33 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
   }
 };
 
-const _checkPeriodicEventsSingleTenantOneTime = async () =>
-  eventQueueConfig.updatePeriodicEvents &&
-  cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));
+const _checkPeriodicEventsSingleTenantOneTime = async () => {
+  const logger = cds.log(COMPONENT_NAME);
+  if (!eventQueueConfig.updatePeriodicEvents || !eventQueueConfig.periodicEvents.length) {
+    logger.info("updating of periodic events is disabled or no periodic events configured", {
+      updateEnabled: eventQueueConfig.updatePeriodicEvents,
+      events: eventQueueConfig.periodicEvents.length,
+    });
+    return;
+  }
+
+  const dummyContext = new cds.EventContext({});
+  return await trace(
+    dummyContext,
+    "update-periodic-events",
+    async () => {
+      const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+        expiryTime: 60 * 1000,
+        tenantScoped: false,
+      });
+      if (!couldAcquireLock) {
+        return;
+      }
+      return await cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));
+    },
+    { newRootSpan: true }
+  );
+};
 
 const _checkPeriodicEventsSingleTenant = async (context) => {
   const logger = cds.log(COMPONENT_NAME);
@@ -417,7 +491,7 @@ const _checkPeriodicEventsSingleTenant = async (context) => {
   try {
     logger.info("executing updating periodic events", {
       tenantId: context.tenant,
-      subdomain: context.user?.authInfo?.getSubdomain(),
+      subdomain: context.user?.tokenInfo?.extAttributes?.zdn,
     });
     await periodicEvents.checkAndInsertPeriodicEvents(context);
   } catch (err) {
@@ -429,12 +503,14 @@ const _checkPeriodicEventsSingleTenant = async (context) => {
 };
 
 module.exports = {
-  singleTenant,
+  singleTenantDb,
   multiTenancyDb,
   multiTenancyRedis,
+  singleTenantRedis,
   __: {
     _singleTenantDb,
     _multiTenancyRedis,
+    _singleTenantRedis,
     _multiTenancyDb,
     _calculateOffsetForFirstRun,
     _acquireRunId,

package/src/shared/SetIntervalDriftSafe.js

@@ -2,8 +2,6 @@
 
 const COMPONENT = "eventQueue/SetIntervalDriftSafe";
 
-const ALLOWED_SHIFT_IN_PROCENT = 0.1;
-
 class SetIntervalDriftSafe {
   #adjustedInterval;
   #interval;
@@ -21,12 +19,6 @@ class SetIntervalDriftSafe {
     const now = Date.now();
     if (this.#expectedCycleTime === 0) {
       this.#expectedCycleTime = now + this.#interval;
-    } else if (
-      Math.abs(now + this.#interval - this.#nextTickScheduledFor - this.#interval) >
-      this.#interval * ALLOWED_SHIFT_IN_PROCENT
-    ) {
-      this.#logger.log("overlapping ticks, skipping this run");
-      return;
     } else {
       this.#adjustedInterval = this.#interval - (now - this.#expectedCycleTime);
       this.#expectedCycleTime += this.#interval;

package/src/shared/cdsHelper.js

@@ -5,6 +5,7 @@ const cds = require("@sap/cds");
 
 const config = require("../config");
 const common = require("./common");
+const { TenantIdCheckTypes } = require("../constants");
 
 const VERROR_CLUSTER_NAME = "ExecuteInNewTransactionError";
 const COMPONENT_NAME = "/eventQueue/cdsHelper";
@@ -23,7 +24,7 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(context.tenant) });
+    const user = new cds.User.Privileged({ id: config.userId, tokenInfo: await common.getTokenInfo(context.tenant) });
     if (cds.db.kind === "hana") {
       await cds.tx(
         {
@@ -116,11 +117,9 @@ const getAllTenantIds = async () => {
   const response = await ssp.get("/tenant");
   return response
     .map((tenant) => tenant.subscribedTenantId ?? tenant.tenant)
-    .filter((tenantId) => !isFakeTenant(tenantId));
+    .filter((tenantId) => common.isTenantIdValidCb(TenantIdCheckTypes.getAllTenantIds, tenantId));
 };
 
-const isFakeTenant = (tenantId) => /00000000-0000-4000-8000-\d{12}/.test(tenantId);
-
 module.exports = {
   executeInNewTransaction,
   TriggerRollback,

package/src/shared/common.js

@@ -4,6 +4,8 @@ const crypto = require("crypto");
 
 const cds = require("@sap/cds");
 const xssec = require("@sap/xssec");
+const config = require("../config");
+const { TenantIdCheckTypes } = require("../constants");
 
 const MARGIN_AUTH_INFO_EXPIRY = 60 * 1000;
 const COMPONENT_NAME = "/eventQueue/common";
@@ -68,45 +70,57 @@ const processChunkedSync = (inputs, chunkSize, chunkHandler) => {
 
 const hashStringTo32Bit = (value) => crypto.createHash("sha256").update(String(value)).digest("base64").slice(0, 32);
 
-const _getNewAuthInfo = async (tenantId) => {
-  const authInfoCache = getAuthInfo._authInfoCache;
-  authInfoCache[tenantId] = authInfoCache[tenantId] ?? {};
+const _getNewTokenInfo = async (tenantId) => {
+  const tokenInfoCache = getTokenInfo._tokenInfoCache;
+  tokenInfoCache[tenantId] = tokenInfoCache[tenantId] ?? {};
   try {
-    if (!_getNewAuthInfo._xsuaaService) {
-      _getNewAuthInfo._xsuaaService = new xssec.XsuaaService(cds.requires.auth.credentials);
+    if (!_getNewTokenInfo._xsuaaService) {
+      _getNewTokenInfo._xsuaaService = new xssec.XsuaaService(cds.requires.auth.credentials);
     }
-    const authService = _getNewAuthInfo._xsuaaService;
+    const authService = _getNewTokenInfo._xsuaaService;
     const token = await authService.fetchClientCredentialsToken({ zid: tenantId });
-    const authInfo = await authService.createSecurityContext(token.access_token);
-    authInfoCache[tenantId].expireTs = authInfo.getExpirationDate().getTime() - MARGIN_AUTH_INFO_EXPIRY;
-    return authInfo;
+    const tokenInfo = new xssec.XsuaaToken(token.access_token);
+    tokenInfoCache[tenantId].expireTs = tokenInfo.getExpirationDate().getTime() - MARGIN_AUTH_INFO_EXPIRY;
+    return tokenInfo;
   } catch (err) {
-    authInfoCache[tenantId] = null;
-    cds.log(COMPONENT_NAME).warn("failed to request authInfo", err);
+    tokenInfoCache[tenantId] = null;
+    cds.log(COMPONENT_NAME).warn("failed to request tokenInfo", err);
   }
 };
 
-const getAuthInfo = async (tenantId) => {
+const getTokenInfo = async (tenantId) => {
+  if (!isTenantIdValidCb(TenantIdCheckTypes.getTokenInfo, tenantId)) {
+    return null;
+  }
+
   if (!cds.requires?.auth?.credentials) {
-    return null; // no credentials not authInfo
+    return null; // no credentials not tokenInfo
   }
   if (!cds.requires?.auth.kind.match(/jwt|xsuaa/i)) {
     cds.log(COMPONENT_NAME).warn("Only 'jwt' or 'xsuaa' are supported as values for auth.kind.");
     return null;
   }
 
-  getAuthInfo._authInfoCache = getAuthInfo._authInfoCache ?? {};
-  const authInfoCache = getAuthInfo._authInfoCache;
+  getTokenInfo._tokenInfoCache = getTokenInfo._tokenInfoCache ?? {};
+  const tokenInfoCache = getTokenInfo._tokenInfoCache;
   // not existing or existing but expired
   if (
-    !authInfoCache[tenantId] ||
-    (authInfoCache[tenantId] && authInfoCache[tenantId].expireTs && Date.now() > authInfoCache[tenantId].expireTs)
+    !tokenInfoCache[tenantId] ||
+    (tokenInfoCache[tenantId] && tokenInfoCache[tenantId].expireTs && Date.now() > tokenInfoCache[tenantId].expireTs)
   ) {
-    authInfoCache[tenantId] ??= {};
-    authInfoCache[tenantId].value = _getNewAuthInfo(tenantId);
-    authInfoCache[tenantId].expireTs = null;
+    tokenInfoCache[tenantId] ??= {};
+    tokenInfoCache[tenantId].value = _getNewTokenInfo(tenantId);
+    tokenInfoCache[tenantId].expireTs = null;
+  }
+  return await tokenInfoCache[tenantId].value;
+};
+
+const isTenantIdValidCb = (checkType, tenantId) => {
+  if (config.tenantIdFilterCb) {
+    return config.tenantIdFilterCb(checkType, tenantId);
+  } else {
+    return true;
   }
-  return await authInfoCache[tenantId].value;
 };
 
 module.exports = {
@@ -115,8 +129,9 @@ module.exports = {
   isValidDate,
   processChunkedSync,
   hashStringTo32Bit,
-  getAuthInfo,
+  getTokenInfo,
+  isTenantIdValidCb,
   __: {
-    clearAuthInfoCache: () => (getAuthInfo._authInfoCache = {}),
+    clearTokenInfoCache: () => (getTokenInfo._tokenInfoCache = {}),
   },
 };

package/src/shared/distributedLock.js

@@ -60,7 +60,7 @@ const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true
 const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
   const result = await client.set(fullKey, value, {
-    PX: expiryTime,
+    PX: Math.round(expiryTime),
     ...(overrideValue ? null : { NX: true }),
   });
   const isOk = result === REDIS_COMMAND_OK;
@@ -117,7 +117,10 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
             .where("code =", fullKey)
         );
       }
-      if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
+      if (
+        overrideValue ||
+        (currentEntry && new Date(currentEntry.createdAt).getTime() + Math.round(expiryTime) <= Date.now())
+      ) {
         await tx.run(
           UPDATE.entity(config.tableNameEventLock)
             .set({

package/src/shared/eventScheduler.js

@@ -51,19 +51,10 @@ class EventScheduler {
   }
 
   calculateOffset(type, subType, startAfter) {
-    const eventConfig = config.getEventConfig(type, subType);
-    const scheduleWithoutDelay = config.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
-    const date = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
-
+    const date = startAfter;
     return { date, relative: date.getTime() - Date.now() };
   }
 
-  calculateFutureTime(date, seoncds) {
-    const startAfterSeconds = date.getSeconds();
-    const secondsUntil = seoncds - (startAfterSeconds % seoncds);
-    return new Date(date.getTime() + secondsUntil * 1000);
-  }
-
   clearScheduledEvents() {
     this.#scheduledEvents = {};
   }

package/src/shared/redis.js

@@ -50,25 +50,27 @@ const _createClientBase = (redisOptions) => {
   }
 };
 
-const createClientAndConnect = async (options, errorHandlerCreateClient) => {
+const createClientAndConnect = async (options, errorHandlerCreateClient, isConnectionCheck) => {
   try {
     const client = _createClientBase(options);
-    await client.connect();
-    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);
-        lastErrorLog = dateNow;
-      }
-    });
+    if (!isConnectionCheck) {
+      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);
+          lastErrorLog = dateNow;
+        }
+      });
 
-    client.on("reconnecting", () => {
-      const dateNow = Date.now();
-      if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
-        cds.log(COMPONENT_NAME).info("redis client trying reconnect...");
-        lastErrorLog = dateNow;
-      }
-    });
+      client.on("reconnecting", () => {
+        const dateNow = Date.now();
+        if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
+          cds.log(COMPONENT_NAME).info("redis client trying reconnect...");
+          lastErrorLog = dateNow;
+        }
+      });
+    }
+    await client.connect();
     return client;
   } catch (err) {
     errorHandlerCreateClient(err);
@@ -119,7 +121,7 @@ const _resilientClientClose = async (client) => {
 
 const connectionCheck = async (options) => {
   return new Promise((resolve, reject) => {
-    createClientAndConnect(options, reject)
+    createClientAndConnect(options, reject, true)
       .then((client) => {
         if (client) {
           _resilientClientClose(client);
@@ -131,7 +133,10 @@ const connectionCheck = async (options) => {
       .catch(reject);
   })
     .then(() => true)
-    .catch(() => false);
+    .catch((err) => {
+      cds.log(COMPONENT_NAME).error("Redis connection check failed! Falling back to NO_REDIS mode", err);
+      return false;
+    });
 };
 
 module.exports = {