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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "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",
@@ -50,15 +50,15 @@
     "yaml": "^2.6.1"
   },
   "devDependencies": {
-    "@cap-js/hana": "^1.3.0",
-    "@cap-js/sqlite": "^1.7.3",
-    "@sap/cds": "^8.4.2",
-    "@sap/cds-dk": "^8.4.2",
+    "@cap-js/hana": "^1.5.2",
+    "@cap-js/sqlite": "^1.7.8",
+    "@sap/cds": "^8.6.0",
+    "@sap/cds-dk": "^8.6.1",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",
     "eslint-plugin-node": "^11.1.0",
-    "express": "^4.21.0",
+    "express": "^4.21.2",
     "hdb": "^0.19.10",
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
@@ -75,13 +75,19 @@
         "disableRedis": false
       },
       "[test]": {
-        "isRunnerDeactivated": true,
+        "isEventQueueActive": false,
         "registerAsEventProcessor": false,
         "updatePeriodicEvents": false,
         "insertEventsBeforeCommit": false
       }
     },
     "requires": {
+      "redis-eventQueue": {
+        "options": {},
+        "vcap": {
+          "label": "redis-cache"
+        }
+      },
       "event-queue": {
         "model": "@cap-js-community/event-queue"
       }

package/src/EventQueueError.js

@@ -24,6 +24,7 @@ const ERROR_CODES = {
   NOT_ALLOWED_PRIORITY: "NOT_ALLOWED_PRIORITY",
   APP_NAMES_FORMAT: "APP_NAMES_FORMAT",
   APP_INSTANCES_FORMAT: "APP_INSTANCES_FORMAT",
+  MULTI_INSTANCE_PROCESSING_NOT_ALLOWED: "MULTI_INSTANCE_PROCESSING_NOT_ALLOWED",
 };
 
 const ERROR_CODES_META = {
@@ -91,6 +92,9 @@ const ERROR_CODES_META = {
   [ERROR_CODES.INTERVAL_AND_CRON]: {
     message: "For periodic events only the cron or interval parameter can be defined!",
   },
+  [ERROR_CODES.MULTI_INSTANCE_PROCESSING_NOT_ALLOWED]: {
+    message: "The config multiInstanceProcessing is currently only allowed for ad-hoc events and single-tenant-apps.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -326,6 +330,17 @@ class EventQueueError extends VError {
     );
   }
 
+  static multiInstanceProcessingNotAllowed(type, subType) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.MULTI_INSTANCE_PROCESSING_NOT_ALLOWED];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.MULTI_INSTANCE_PROCESSING_NOT_ALLOWED,
+        info: { type, subType },
+      },
+      message
+    );
+  }
+
   static isRedisConnectionFailure(err) {
     return err instanceof VError && err.name === ERROR_CODES.REDIS_CREATE_CLIENT;
   }

package/src/EventQueueProcessorBase.js

@@ -3,7 +3,7 @@
 const cds = require("@sap/cds");
 const cronParser = require("cron-parser");
 
-const { executeInNewTransaction, TriggerRollback } = require("./shared/cdsHelper");
+const { executeInNewTransaction } = require("./shared/cdsHelper");
 const { EventProcessingStatus, TransactionMode } = require("./constants");
 const distributedLock = require("./shared/distributedLock");
 const EventQueueError = require("./EventQueueError");
@@ -61,8 +61,7 @@ class EventQueueProcessorBase {
       this.__parallelEventProcessing = LIMIT_PARALLEL_EVENT_PROCESSING;
     }
     this.#retryFailedAfter = this.#eventConfig.retryFailedAfter ?? DEFAULT_RETRY_AFTER;
-    // NOTE: keep the feature, this might be needed again
-    this.__concurrentEventProcessing = false;
+    this.__concurrentEventProcessing = this.#eventConfig.multiInstanceProcessing;
     this.__startTime = this.#eventConfig.startTime ?? new Date();
     this.__retryAttempts = this.#isPeriodic ? 1 : this.#eventConfig.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS;
     this.__selectMaxChunkSize = this.#eventConfig.selectMaxChunkSize ?? SELECT_LIMIT_EVENTS_PER_TICK;
@@ -786,7 +785,7 @@ class EventQueueProcessorBase {
               await executeInNewTransaction(this.context, "error-hookForExceededEvents", async (tx) =>
                 this.#persistEventQueueStatusForExceeded(tx, [exceededEvent], EventProcessingStatus.Error)
               );
-              throw new TriggerRollback();
+              await tx.rollback();
             }
           }
         );
@@ -918,7 +917,8 @@ class EventQueueProcessorBase {
     return await trace(this.baseContext, "acquire-lock", async () => {
       const lockAcquired = await distributedLock.acquireLock(
         this.context,
-        [this.#eventType, this.#eventSubType].join("##")
+        [this.#eventType, this.#eventSubType].join("##"),
+        { keepTrackOfLock: true }
       );
       if (!lockAcquired) {
         this.logger.debug("no lock available, exit processing", {

package/src/config.js

@@ -113,7 +113,7 @@ class Config {
   }
 
   _checkRedisIsBound() {
-    return !!this.#env.redisCredentialsFromEnv;
+    return !!this.#env.redisRequires?.credentials;
   }
 
   shouldBeProcessedInThisApplication(type, subType) {
@@ -445,6 +445,11 @@ class Config {
     if (!event.interval || event.interval <= MIN_INTERVAL_SEC) {
       throw EventQueueError.invalidInterval(event.type, event.subType, event.interval);
     }
+
+    if (event.multiInstanceProcessing) {
+      throw EventQueueError.multiInstanceProcessingNotAllowed(event.type, event.subType);
+    }
+
     this.#basicEventValidation(event);
   }
 
@@ -453,6 +458,11 @@ class Config {
     if (eventMap[key] && !eventMap[key].isPeriodic) {
       throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
+
+    if (this.isMultiTenancy && event.multiInstanceProcessing) {
+      throw EventQueueError.multiInstanceProcessingNotAllowed(event.type, event.subType);
+    }
+
     this.#basicEventValidation(event);
   }
 

package/src/index.d.ts

@@ -11,6 +11,11 @@ export declare const EventProcessingStatus: {
 declare type EventProcessingStatusKeysType = keyof typeof EventProcessingStatus;
 export declare type EventProcessingStatusType = (typeof EventProcessingStatus)[EventProcessingStatusKeysType];
 
+export declare const TenantIdCheckTypes: {
+  getAllTenantIds: "getAllTenantIds";
+  getTokenInfo: "getTokenInfo";
+};
+
 export declare const TransactionMode: {
   isolated: "isolated";
   alwaysCommit: "alwaysCommit";

package/src/processEventQueue.js

@@ -8,7 +8,7 @@ const config = require("./config");
 const { TransactionMode, EventProcessingStatus } = require("./constants");
 const { limiter } = require("./shared/common");
 
-const { executeInNewTransaction, TriggerRollback } = require("./shared/cdsHelper");
+const { executeInNewTransaction } = require("./shared/cdsHelper");
 const trace = require("./shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/processEventQueue";
@@ -65,7 +65,7 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
               eventTypeInstance.handleErrorDuringProcessing(err, queueEntry);
             }
           }
-          throw new TriggerRollback();
+          await tx.rollback();
         });
       });
       await eventTypeInstance.handleExceededEvents();
@@ -89,7 +89,7 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
                 eventTypeInstance.shouldRollbackTransaction(key)
               )
             ) {
-              throw new TriggerRollback();
+              await tx.rollback();
             }
           });
         });
@@ -167,7 +167,8 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
             } catch (err) {
               status = EventProcessingStatus.Error;
               eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
-              throw new TriggerRollback();
+              await tx.rollback();
+              return;
             } finally {
               eventTypeInstance.endPerformanceTracerPeriodicEvents();
             }
@@ -175,7 +176,7 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
               eventTypeInstance.transactionMode === TransactionMode.alwaysRollback ||
               eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
             ) {
-              throw new TriggerRollback();
+              await tx.rollback();
             }
           });
         }
@@ -222,7 +223,7 @@ const processEventMap = async (eventTypeInstance) => {
               eventTypeInstance.statusMapContainsError(statusMap) ||
               eventTypeInstance.shouldRollbackTransaction(key)
             ) {
-              throw new TriggerRollback();
+              await tx.rollback();
             }
           }
         );

package/src/redis/redisPub.js

@@ -5,7 +5,7 @@ const { promisify } = require("util");
 const cds = require("@sap/cds");
 
 const redis = require("../shared/redis");
-const { checkLockExistsAndReturnValue } = require("../shared/distributedLock");
+const distributedLock = require("../shared/distributedLock");
 const config = require("../config");
 const common = require("../shared/common");
 const { runEventCombinationForTenant } = require("../runner/runnerHelper");
@@ -67,7 +67,9 @@ const broadcastEvent = async (tenantId, events, forceBroadcast = false) => {
         for (const { type, subType } of events) {
           const eventConfig = config.getEventConfig(type, subType);
           for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
-            const result = await checkLockExistsAndReturnValue(context, [type, subType].join("##"));
+            const result = eventConfig.multiInstanceProcessing
+              ? false
+              : await distributedLock.checkLockExistsAndReturnValue(context, [type, subType].join("##"));
             if (result) {
               logger.debug("skip publish redis event as no lock is available", {
                 type,

package/src/runner/runner.js

@@ -281,9 +281,11 @@ const _singleTenantDb = async () => {
             async () => {
               try {
                 const lockId = `${label}`;
-                const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-                  expiryTime: eventQueueConfig.runInterval * 0.95,
-                });
+                const couldAcquireLock = eventConfig.multiInstanceProcessing
+                  ? true
+                  : await distributedLock.acquireLock(context, lockId, {
+                      expiryTime: eventQueueConfig.runInterval * 0.95,
+                    });
                 if (!couldAcquireLock) {
                   return;
                 }

package/src/runner/runnerHelper.js

@@ -25,7 +25,7 @@ const runEventCombinationForTenant = async (context, type, subType, { skipWorker
         eventConfig.priority,
         AsyncResource.bind(async () => {
           const _exec = async () => {
-            if (lockId) {
+            if (!eventConfig.multiInstanceProcessing && lockId) {
               const lockAvailable = await distributedLock.acquireLock(context, lockId);
               if (!lockAvailable) {
                 return;

package/src/shared/cdsHelper.js

@@ -62,42 +62,34 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
         } catch {
           /* empty */
         }
-        await fn(contextTx, ...parameters);
+        const txRollback = contextTx.rollback;
+        contextTx.rollback = async () => {
+          // tx should not be managed here as we did not open the tx
+          // 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));
       }
     }
   } catch (err) {
-    if (!(err instanceof TriggerRollback)) {
-      if (err instanceof VError) {
-        Object.assign(err.jse_info, {
-          newTx: info,
-        });
-        throw err;
-      } else {
-        throw new VError(
-          {
-            name: VERROR_CLUSTER_NAME,
-            cause: err,
-            info,
-          },
-          "Execution in new transaction failed"
-        );
-      }
+    if (err instanceof VError) {
+      Object.assign(err.jse_info, {
+        newTx: info,
+      });
+      throw err;
+    } else {
+      throw new VError(
+        {
+          name: VERROR_CLUSTER_NAME,
+          cause: err,
+          info,
+        },
+        "Execution in new transaction failed"
+      );
     }
-    return false;
   } finally {
     logger.debug("Execution in new transaction finished", info);
   }
-  return true;
-}
-
-/**
- * Error class to be used to force rollback in executionInNewTransaction
- * Error will not be logged, as it assumes that error handling has been done before...
- */
-class TriggerRollback extends VError {
-  constructor() {
-    super("Rollback triggered");
-  }
 }
 
 const getAllTenantIds = async () => {
@@ -122,6 +114,5 @@ const getAllTenantIds = async () => {
 
 module.exports = {
   executeInNewTransaction,
-  TriggerRollback,
   getAllTenantIds,
 };

package/src/shared/distributedLock.js

@@ -5,15 +5,18 @@ const config = require("../config");
 const cdsHelper = require("./cdsHelper");
 
 const KEY_PREFIX = "EVENT_QUEUE";
-
 const existingLocks = {};
-
 const REDIS_COMMAND_OK = "OK";
+const COMPONENT_NAME = "/eventQueue/distributedLock";
 
-const acquireLock = async (context, key, { tenantScoped = true, expiryTime = config.globalTxTimeout } = {}) => {
+const acquireLock = async (
+  context,
+  key,
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, keepTrackOfLock = false } = {}
+) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.redisEnabled) {
-    return await _acquireLockRedis(context, fullKey, expiryTime);
+    return await _acquireLockRedis(context, fullKey, expiryTime, { keepTrackOfLock });
   } else {
     return await _acquireLockDB(context, fullKey, expiryTime);
   }
@@ -23,13 +26,14 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  { tenantScoped = true, expiryTime = config.globalTxTimeout, overrideValue = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, overrideValue = false, keepTrackOfLock = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, {
       value,
       overrideValue,
+      keepTrackOfLock,
     });
   } else {
     return await _acquireLockDB(context, fullKey, expiryTime, {
@@ -57,14 +61,19 @@ const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true
   }
 };
 
-const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
+const _acquireLockRedis = async (
+  context,
+  fullKey,
+  expiryTime,
+  { value = "true", overrideValue = false, keepTrackOfLock } = {}
+) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
   const result = await client.set(fullKey, value, {
     PX: Math.round(expiryTime),
     ...(overrideValue ? null : { NX: true }),
   });
   const isOk = result === REDIS_COMMAND_OK;
-  if (isOk) {
+  if (isOk && keepTrackOfLock) {
     existingLocks[fullKey] = 1;
   }
   return isOk;
@@ -146,7 +155,21 @@ const _generateKey = (context, tenantScoped, key) => {
 };
 
 const shutdownHandler = async () => {
-  await Promise.allSettled(Object.keys(existingLocks).map((key) => _releaseLockRedis(null, key)));
+  const logger = cds.log(COMPONENT_NAME);
+  logger.info("received shutdown event, trying to release all locks", {
+    numberOfLocks: Object.keys(existingLocks).length,
+  });
+  const result = await Promise.allSettled(
+    Object.keys(existingLocks).map(async (key) => {
+      await _releaseLockRedis(null, key);
+      logger.info("lock released", { key });
+    })
+  );
+  const errors = result.filter((promise) => promise.reason);
+  logger.info("releasing locks finished ", {
+    numberOfErrors: errors.length,
+    ...(errors.length && { firstError: errors[0] }),
+  });
 };
 
 module.exports = {

package/src/shared/env.js

@@ -1,25 +1,24 @@
 "use strict";
 
+const cds = require("@sap/cds");
+
 let instance;
 
 class Env {
-  #vcapServices;
   #vcapApplication;
   #vcapApplicationInstance;
 
   constructor() {
     try {
-      this.#vcapServices = JSON.parse(process.env.VCAP_SERVICES);
       this.#vcapApplication = JSON.parse(process.env.VCAP_APPLICATION);
     } catch {
-      this.#vcapServices = {};
       this.#vcapApplication = {};
     }
     this.#vcapApplicationInstance = Number(process.env.CF_INSTANCE_INDEX);
   }
 
-  get redisCredentialsFromEnv() {
-    return this.#vcapServices["redis-cache"]?.[0]?.credentials;
+  get redisRequires() {
+    return cds.requires["redis-eventQueue"] ?? cds.requires["redis"];
   }
 
   get applicationName() {
@@ -30,14 +29,6 @@ class Env {
     return this.#vcapApplicationInstance;
   }
 
-  set vcapServices(value) {
-    this.#vcapServices = value;
-  }
-
-  get vcapServices() {
-    return this.#vcapServices;
-  }
-
   set applicationInstance(value) {
     this.#vcapApplicationInstance = value;
   }

package/src/shared/redis.js

@@ -27,24 +27,30 @@ const createMainClientAndConnect = (options) => {
   return mainClientPromise;
 };
 
-const _createClientBase = (redisOptions) => {
+const _createClientBase = (redisOptions = {}) => {
   const env = getEnvInstance();
   try {
-    const credentials = env.redisCredentialsFromEnv;
-    const redisIsCluster = credentials.cluster_mode;
-    const url = credentials.uri.replace(/(?<=rediss:\/\/)[\w-]+?(?=:)/, "");
-    if (redisIsCluster) {
+    const { credentials, options } = env.redisRequires;
+    const socket = Object.assign(
+      {
+        host: credentials.hostname,
+        tls: !!credentials.tls,
+        port: credentials.port,
+      },
+      options?.socket,
+      redisOptions.socket
+    );
+    const socketOptions = Object.assign({}, options, redisOptions, {
+      password: redisOptions.password ?? options.password ?? credentials.password,
+      socket,
+    });
+    if (credentials.cluster_mode) {
       return redis.createCluster({
-        rootNodes: [{ url }],
-        // https://github.com/redis/node-redis/issues/1782
-        defaults: {
-          password: credentials.password,
-          socket: { tls: credentials.tls },
-          ...redisOptions,
-        },
+        rootNodes: [socketOptions],
+        defaults: socketOptions,
       });
     }
-    return redis.createClient({ url, ...redisOptions });
+    return redis.createClient(socketOptions);
   } catch (err) {
     throw EventQueueError.redisConnectionFailure(err);
   }