@cap-js-community/event-queue 1.8.5 → 1.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.8.5",
+  "version": "1.8.7",
   "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/config.js

@@ -17,6 +17,7 @@ const COMPONENT_NAME = "/eventQueue/config";
 const MIN_INTERVAL_SEC = 10;
 const DEFAULT_LOAD = 1;
 const DEFAULT_PRIORITY = Priorities.Medium;
+const DEFAULT_INCREASE_PRIORITY = true;
 const SUFFIX_PERIODIC = "_PERIODIC";
 const COMMAND_BLOCK = "EVENT_QUEUE_EVENT_BLOCK";
 const COMMAND_UNBLOCK = "EVENT_QUEUE_EVENT_UNBLOCK";
@@ -317,6 +318,7 @@ class Config {
       retryFailedAfter: config.retryFailedAfter,
       priority: config.priority,
       multiInstanceProcessing: config.multiInstanceProcessing,
+      increasePriorityOverTime: config.increasePriorityOverTime,
       internalEvent: true,
     };
 
@@ -364,7 +366,6 @@ class Config {
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
-      event.priority = event.priority ?? DEFAULT_PRIORITY;
       event.type = `${event.type}${SUFFIX_PERIODIC}`;
       event.isPeriodic = true;
       this.#basicEventTransformation(event);
@@ -378,6 +379,7 @@ class Config {
   #basicEventTransformation(event) {
     event.load = event.load ?? DEFAULT_LOAD;
     event.priority = event.priority ?? DEFAULT_PRIORITY;
+    event.increasePriorityOverTime = event.increasePriorityOverTime ?? DEFAULT_INCREASE_PRIORITY;
   }
 
   #basicEventTransformationAfterValidate(event) {

package/src/index.d.ts

@@ -269,7 +269,13 @@ export const workerQueue: WorkerQueue;
 declare class WorkerQueue {
   constructor(concurrency: number);
 
-  addToQueue(load: number, label: string, priority?: Priorities, cb?: () => any): Promise<any>;
+  addToQueue(
+    load: number,
+    label: string,
+    priority: Priorities,
+    increasePriorityOverTime: boolean,
+    cb: () => any
+  ): Promise<any>;
 
   _executeFunction(
     load: number,

package/src/publishEvent.js

@@ -34,7 +34,8 @@ const publishEvent = async (tx, events, { skipBroadcast = false, skipInsertEvent
     throw EventQueueError.notInitialized();
   }
   const eventsForProcessing = Array.isArray(events) ? events : [events];
-  for (const { type, subType, startAfter } of eventsForProcessing) {
+  for (const event of eventsForProcessing) {
+    const { type, subType, startAfter } = event;
     const eventConfig = config.getEventConfig(type, subType);
     if (!eventConfig) {
       throw EventQueueError.unknownEventType(type, subType);
@@ -46,8 +47,11 @@ const publishEvent = async (tx, events, { skipBroadcast = false, skipInsertEvent
     if (eventConfig.isPeriodic) {
       throw EventQueueError.manuelPeriodicEventInsert(type, subType);
     }
-  }
 
+    if (typeof event.payload !== "string") {
+      event.payload = JSON.stringify(event.payload);
+    }
+  }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);
   } else {

package/src/runner/runner.js

@@ -194,33 +194,39 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
       events.map(async (openEvent) => {
         const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType);
         const label = `${eventConfig.type}_${eventConfig.subType}`;
-        return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
-          return await cds.tx(tenantContext, async ({ context }) => {
-            await trace(
-              context,
-              label,
-              async () => {
-                try {
-                  const lockId = `${runId}_${label}`;
-                  const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-                    expiryTime: eventQueueConfig.runInterval * 0.95,
-                  });
-                  if (!couldAcquireLock) {
-                    return;
+        return await WorkerQueue.instance.addToQueue(
+          eventConfig.load,
+          label,
+          eventConfig.priority,
+          eventConfig.increasePriorityOverTime,
+          async () => {
+            return await cds.tx(tenantContext, async ({ context }) => {
+              await trace(
+                context,
+                label,
+                async () => {
+                  try {
+                    const lockId = `${runId}_${label}`;
+                    const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
+                      expiryTime: eventQueueConfig.runInterval * 0.95,
+                    });
+                    if (!couldAcquireLock) {
+                      return;
+                    }
+                    await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
+                      skipWorkerPool: true,
+                    });
+                  } catch (err) {
+                    cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+                      tenantId,
+                    });
                   }
-                  await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
-                    skipWorkerPool: true,
-                  });
-                } catch (err) {
-                  cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-                    tenantId,
-                  });
-                }
-              },
-              { newRootSpan: true }
-            );
-          });
-        });
+                },
+                { newRootSpan: true }
+              );
+            });
+          }
+        );
       })
     );
   }
@@ -275,33 +281,39 @@ const _singleTenantDb = async () => {
     events.map(async (openEvent) => {
       const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType);
       const label = `${eventConfig.type}_${eventConfig.subType}`;
-      return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
-        return await cds.tx({}, async ({ context }) => {
-          await trace(
-            context,
-            label,
-            async () => {
-              try {
-                const lockId = `${label}`;
-                const couldAcquireLock = eventConfig.multiInstanceProcessing
-                  ? true
-                  : await distributedLock.acquireLock(context, lockId, {
-                      expiryTime: eventQueueConfig.runInterval * 0.95,
-                    });
-                if (!couldAcquireLock) {
-                  return;
+      return await WorkerQueue.instance.addToQueue(
+        eventConfig.load,
+        label,
+        eventConfig.priority,
+        eventConfig.increasePriorityOverTime,
+        async () => {
+          return await cds.tx({}, async ({ context }) => {
+            await trace(
+              context,
+              label,
+              async () => {
+                try {
+                  const lockId = `${label}`;
+                  const couldAcquireLock = eventConfig.multiInstanceProcessing
+                    ? true
+                    : await distributedLock.acquireLock(context, lockId, {
+                        expiryTime: eventQueueConfig.runInterval * 0.95,
+                      });
+                  if (!couldAcquireLock) {
+                    return;
+                  }
+                  await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
+                    skipWorkerPool: true,
+                  });
+                } catch (err) {
+                  cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
                 }
-                await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, {
-                  skipWorkerPool: true,
-                });
-              } catch (err) {
-                cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
-              }
-            },
-            { newRootSpan: true }
-          );
-        });
-      });
+              },
+              { newRootSpan: true }
+            );
+          });
+        }
+      );
     })
   );
 };

package/src/runner/runnerHelper.js

@@ -23,6 +23,7 @@ const runEventCombinationForTenant = async (context, type, subType, { skipWorker
         eventConfig.load,
         label,
         eventConfig.priority,
+        eventConfig.increasePriorityOverTime,
         AsyncResource.bind(async () => {
           const _exec = async () => {
             if (!eventConfig.multiInstanceProcessing && lockId) {

package/src/shared/WorkerQueue.js

@@ -52,7 +52,7 @@ class WorkerQueue {
     runner.run(this.#adjustPriority.bind(this));
   }
 
-  addToQueue(load, label, priority = Priorities.Medium, cb) {
+  addToQueue(load, label, priority = Priorities.Medium, increasePriorityOverTime, cb) {
     if (load > this.#concurrencyLimit) {
       throw EventQueueError.loadHigherThanLimit(load, label);
     }
@@ -63,7 +63,7 @@ class WorkerQueue {
 
     const startTime = process.hrtime.bigint();
     const p = new Promise((resolve, reject) => {
-      this.#queue[priority].push([load, label, cb, resolve, reject, startTime]);
+      this.#queue[priority].push([load, label, cb, resolve, reject, increasePriorityOverTime, startTime]);
     });
     this.#checkForNext();
     return p;
@@ -78,7 +78,12 @@ class WorkerQueue {
       const nextPriority = priorityValues[i + 1];
       for (let i = 0; i < this.queue[priority].length; i++) {
         const queueEntry = this.queue[priority][i];
-        const startTime = queueEntry[6] ?? queueEntry[5];
+        // NOTE: index 5 - increasingPrioOverTime
+        if (!queueEntry[5]) {
+          continue;
+        }
+        // NOTE: index 6 original time; index 7 shifted time
+        const startTime = queueEntry[7] ?? queueEntry[6];
         if (Math.round(Number(checkTime - startTime) / NANO_TO_MS) > INCREASE_PRIORITY_AFTER * MIN_TO_MS) {
           const [entry] = this.queue[priority].splice(i, 1);
           entry.push(checkTime);
@@ -88,7 +93,7 @@ class WorkerQueue {
     }
   }
 
-  _executeFunction(load, label, cb, resolve, reject, startTime, priority) {
+  _executeFunction(priority, load, label, cb, resolve, reject, skipIncreasingPrioOverTime, startTime) {
     this.#checkAndLogWaitingTime(startTime, label, priority);
     const promise = Promise.resolve().then(() => cb());
     this.#runningPromises.push(promise);
@@ -123,7 +128,7 @@ class WorkerQueue {
         const [load] = this.#queue[priority][i];
         if (this.#runningLoad + load <= this.#concurrencyLimit) {
           const [args] = this.#queue[priority].splice(i, 1);
-          this._executeFunction(...args, priority);
+          this._executeFunction(priority, ...args);
           entryFound = true;
           break;
         }

package/src/shared/common.js

@@ -101,18 +101,27 @@ const _getNewTokenInfo = async (tenantId) => {
     return tokenInfo;
   } catch (err) {
     tokenInfoCache[tenantId] = null;
-    cds.log(COMPONENT_NAME).warn("failed to request tokenInfo", err);
+    cds.log(COMPONENT_NAME).warn("failed to request tokenInfo", {
+      err: err.message,
+      responseCode: err.responseCode,
+      responseText: err.responseText,
+    });
   }
 };
 
 const getTokenInfo = async (tenantId) => {
-  if (!isTenantIdValidCb(TenantIdCheckTypes.getTokenInfo, tenantId)) {
+  if (!(await isTenantIdValidCb(TenantIdCheckTypes.getTokenInfo, tenantId))) {
     return null;
   }
 
   if (!cds.requires?.auth?.credentials) {
     return null; // no credentials not tokenInfo
   }
+
+  if (!config.isMultiTenancy) {
+    return null; // does only make sense for multi tenancy
+  }
+
   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;