@cap-js-community/event-queue 0.2.2 → 0.2.4

package/src/shared/WorkerQueue.js

@@ -2,66 +2,107 @@
 
 const cds = require("@sap/cds");
 
-const { getConfigInstance } = require("../config");
+const config = require("../config");
+const EventQueueError = require("../EventQueueError");
 
 const COMPONENT_NAME = "eventQueue/WorkerQueue";
-
-let instance = null;
+const NANO_TO_MS = 1e6;
+const THRESHOLD = {
+  INFO: 5 * 1000,
+  WARN: 10 * 1000,
+  ERROR: 15 * 1000,
+};
 
 class WorkerQueue {
+  #concurrencyLimit;
+  #runningPromises;
+  #runningLoad;
+  #queue;
+  static #instance;
+
   constructor(concurrency) {
     if (Number.isNaN(concurrency) || concurrency <= 0) {
-      this.__concurrencyLimit = 1;
+      this.#concurrencyLimit = 1;
     } else {
-      this.__concurrencyLimit = concurrency;
+      this.#concurrencyLimit = concurrency;
     }
-    this.__runningPromises = [];
-    this.__queue = [];
+    this.#runningPromises = [];
+    this.#runningLoad = 0;
+    this.#queue = [];
   }
 
-  addToQueue(cb) {
+  addToQueue(load, cb) {
+    if (load > this.#concurrencyLimit) {
+      throw EventQueueError.loadHigherThanLimit(load);
+    }
+
+    const startTime = process.hrtime.bigint();
     const p = new Promise((resolve, reject) => {
-      this.__queue.push([cb, resolve, reject]);
+      this.#queue.push([load, cb, resolve, reject, startTime]);
     });
     this._checkForNext();
     return p;
   }
 
-  _executeFunction(cb, resolve, reject) {
+  _executeFunction(load, cb, resolve, reject, startTime) {
+    this.checkAndLogWaitingTime(startTime);
     const promise = Promise.resolve().then(() => cb());
-    this.__runningPromises.push(promise);
+    this.#runningPromises.push(promise);
+    this.#runningLoad = this.#runningLoad + load;
     promise
       .finally(() => {
-        this.__runningPromises.splice(this.__runningPromises.indexOf(promise), 1);
+        this.#runningLoad = this.#runningLoad - load;
+        this.#runningPromises.splice(this.#runningPromises.indexOf(promise), 1);
         this._checkForNext();
       })
       .then((...results) => {
         resolve(...results);
       })
       .catch((err) => {
-        cds.log(COMPONENT_NAME).error("Error happened in WorkQueue. Errors should be caught before! Error:", err);
+        cds.log(COMPONENT_NAME).error("Error happened in WorkQueue. Errors should be caught before!", err);
         reject(err);
       });
   }
 
   _checkForNext() {
-    if (!this.__queue.length || this.__runningPromises.length >= this.__concurrencyLimit) {
+    const load = this.#queue[0]?.[0];
+    if (!this.#queue.length || this.#runningLoad + load > this.#concurrencyLimit) {
       return;
     }
-    const [cb, resolve, reject] = this.__queue.shift();
-    this._executeFunction(cb, resolve, reject);
+    const args = this.#queue.shift();
+    this._executeFunction(...args);
+  }
+
+  get runningPromises() {
+    return this.#runningPromises;
   }
-}
 
-module.exports = {
-  getWorkerPoolInstance: () => {
-    if (!instance) {
-      const configInstance = getConfigInstance();
-      instance = new WorkerQueue(configInstance.parallelTenantProcessing);
+  /**
+   @return { WorkerQueue }
+   **/
+  static get instance() {
+    if (!WorkerQueue.#instance) {
+      WorkerQueue.#instance = new WorkerQueue(config.parallelTenantProcessing);
     }
-    return instance;
-  },
-  _: {
-    WorkerQueue,
-  },
-};
+    return WorkerQueue.#instance;
+  }
+
+  checkAndLogWaitingTime(startTime) {
+    const diffMs = Math.round(Number(process.hrtime.bigint() - startTime) / NANO_TO_MS);
+    let logLevel;
+    if (diffMs >= THRESHOLD.ERROR) {
+      logLevel = "error";
+    } else if (diffMs >= THRESHOLD.WARN) {
+      logLevel = "warn";
+    } else if (diffMs >= THRESHOLD.INFO) {
+      logLevel = "info";
+    } else {
+      logLevel = "debug";
+    }
+    cds.log(COMPONENT_NAME)[logLevel]("Waiting time in worker queue", {
+      diffMs,
+    });
+  }
+}
+
+module.exports = WorkerQueue;

package/src/shared/cdsHelper.js

@@ -94,7 +94,7 @@ class TriggerRollback extends VError {
 }
 
 const getSubdomainForTenantId = async (tenantId) => {
-  if (!config.getConfigInstance().isMultiTenancy) {
+  if (!config.isMultiTenancy) {
     return null;
   }
   if (subdomainCache[tenantId]) {
@@ -111,7 +111,7 @@ const getSubdomainForTenantId = async (tenantId) => {
 };
 
 const getAllTenantIds = async () => {
-  if (!config.getConfigInstance().isMultiTenancy) {
+  if (!config.isMultiTenancy) {
     return null;
   }
   const ssp = await cds.connect.to("cds.xt.SaasProvisioningService");

package/src/shared/common.js

@@ -1,9 +1,6 @@
 "use strict";
 
 const crypto = require("crypto");
-
-const { floor, abs, min } = Math;
-
 const arrayToFlatMap = (array, key = "ID") => {
   return array.reduce((result, element) => {
     result[element[key]] = element;
@@ -11,74 +8,6 @@ const arrayToFlatMap = (array, key = "ID") => {
   }, {});
 };
 
-/**
- * Establish a "Funnel" instance to limit how much
- * load can be processed in parallel. This is somewhat
- * similar to the limiter function however it has some
- * distinctintly different features. The Funnel will
- * not know in advance which functions and how many
- * loads it will have to process.
- */
-class Funnel {
-  /**
-   * Create a funnel with specified capacity
-   * @param capacity - the capacity of the funnel (integer, sign will be ignored)
-   */
-  constructor(capacity = 100) {
-    this.runningPromises = [];
-    this.capacity = floor(abs(capacity));
-  }
-
-  /**
-   * Asynchronously run a function that will put a specified load to the funnel.
-   * The total amount of load of all running functions shall not
-   * exceed the capacity of the funnel. If the desired load exceeds the capacity
-   * the funnel will wait until sufficient capacity is available.
-   * If a function requires a load >= capacity, then it will run
-   * exclusively.
-   * @param load - the load (integer, sign will be ignored)
-   * @param f
-   * @param args
-   * @return {Promise<unknown>}
-   */
-  async run(load, f, ...args) {
-    load = min(floor(abs(load)), Number.MAX_SAFE_INTEGER);
-
-    // wait for sufficient capacity
-    while (this.capacity < load && this.runningPromises.length > 0) {
-      try {
-        await Promise.race(this.runningPromises);
-      } catch {
-        // Yes, we must ignore exceptions here. The
-        // caller expects exceptions from f and no
-        // exceptions from other workloads.
-        // Other exceptions must be handled by the
-        // other callers. See (*) below.
-      }
-    }
-
-    // map function call to promise
-    const p = f.constructor.name === "AsyncFunction" ? f(...args) : Promise.resolve().then(() => f(...args));
-
-    // create promise for book keeping
-    const workload = p.finally(() => {
-      // remove workload
-      this.runningPromises.splice(this.runningPromises.indexOf(workload), 1);
-      // and reclaim its capacity
-      this.capacity += load;
-    });
-
-    // claim the capacity and schedule workload
-    this.capacity -= load;
-    this.runningPromises.push(workload);
-
-    // make the caller wait for the workload
-    // this also establish the seemingly missing
-    // exception handling. See (*) above.
-    return workload;
-  }
-}
-
 /**
  * Defines a promise that resolves when all payloads are processed by the iterator, but limits
  * the number concurrent executions.
@@ -132,4 +61,4 @@ const processChunkedSync = (inputs, chunkSize, chunkHandler) => {
 
 const hashStringTo32Bit = (value) => crypto.createHash("sha256").update(String(value)).digest("base64").slice(0, 32);
 
-module.exports = { arrayToFlatMap, Funnel, limiter, isValidDate, processChunkedSync, hashStringTo32Bit };
+module.exports = { arrayToFlatMap, limiter, isValidDate, processChunkedSync, hashStringTo32Bit };

package/src/shared/distributedLock.js

@@ -3,15 +3,12 @@
 const redis = require("./redis");
 const config = require("../config");
 const cdsHelper = require("./cdsHelper");
-const { getConfigInstance } = require("../config");
 
-const acquireLock = async (
-  context,
-  key,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout } = {}
-) => {
+const KEY_PREFIX = "EVENT_QUEUE";
+
+const acquireLock = async (context, key, { tenantScoped = true, expiryTime = config.globalTxTimeout } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime);
   } else {
     return await _acquireLockDB(context, fullKey, expiryTime);
@@ -22,10 +19,10 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout, overrideValue = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, overrideValue = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, {
       value,
       overrideValue,
@@ -40,7 +37,7 @@ const setValueWithExpire = async (
 
 const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _releaseLockRedis(context, fullKey);
   } else {
     return await _releaseLockDb(context, fullKey);
@@ -49,7 +46,7 @@ const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
 
 const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _checkLockExistsRedis(context, fullKey);
   } else {
     return await _checkLockExistsDb(context, fullKey);
@@ -72,9 +69,8 @@ const _checkLockExistsRedis = async (context, fullKey) => {
 
 const _checkLockExistsDb = async (context, fullKey) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-checkExists", async (tx) => {
-    result = await tx.run(SELECT.one.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    result = await tx.run(SELECT.one.from(config.tableNameEventLock).where("code =", fullKey));
   });
   return result?.value;
 };
@@ -85,19 +81,17 @@ const _releaseLockRedis = async (context, fullKey) => {
 };
 
 const _releaseLockDb = async (context, fullKey) => {
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
-    await tx.run(DELETE.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    await tx.run(DELETE.from(config.tableNameEventLock).where("code =", fullKey));
   });
 };
 
 const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
     try {
       await tx.run(
-        INSERT.into(configInstance.tableNameEventLock).entries({
+        INSERT.into(config.tableNameEventLock).entries({
           code: fullKey,
           value,
         })
@@ -109,14 +103,14 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
       if (!overrideValue) {
         currentEntry = await tx.run(
           SELECT.one
-            .from(configInstance.tableNameEventLock)
-            .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
+            .from(config.tableNameEventLock)
+            .forUpdate({ wait: config.forUpdateTimeout })
             .where("code =", fullKey)
         );
       }
       if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
         await tx.run(
-          UPDATE.entity(configInstance.tableNameEventLock)
+          UPDATE.entity(config.tableNameEventLock)
             .set({
               createdAt: new Date().toISOString(),
               value,
@@ -136,7 +130,7 @@ const _generateKey = (context, tenantScoped, key) => {
   const keyParts = [];
   tenantScoped && keyParts.push(context.tenant);
   keyParts.push(key);
-  return keyParts.join("##");
+  return `${KEY_PREFIX}_${keyParts.join("##")}`;
 };
 
 module.exports = {

package/src/shared/eventScheduler.js

@@ -13,11 +13,8 @@ class EventScheduler {
   constructor() {}
 
   scheduleEvent(tenantId, type, subType, startAfter) {
-    const configInstance = config.getConfigInstance();
-    const eventConfig = configInstance.getEventConfig(type, subType);
-    const scheduleWithoutDelay = configInstance.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
-    const roundUpDate = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
-    const key = [tenantId, type, subType, roundUpDate.toISOString()].join("##");
+    const { date, relative } = this.calculateOffset(type, subType, startAfter);
+    const key = [tenantId, type, subType, date.toISOString()].join("##");
     if (this.#scheduledEvents[key]) {
       return; // event combination already scheduled
     }
@@ -25,7 +22,7 @@ class EventScheduler {
     cds.log(COMPONENT_NAME).info("scheduling event queue run for delayed event", {
       type,
       subType,
-      delaySeconds: (roundUpDate.getTime() - Date.now()) / 1000,
+      delaySeconds: (date.getTime() - Date.now()) / 1000,
     });
     setTimeout(() => {
       delete this.#scheduledEvents[key];
@@ -34,10 +31,18 @@ class EventScheduler {
           tenantId,
           type,
           subType,
-          scheduledFor: roundUpDate.toISOString(),
+          scheduledFor: date.toISOString(),
         });
       });
-    }, roundUpDate.getTime() - Date.now()).unref();
+    }, relative).unref();
+  }
+
+  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);
+
+    return { date, relative: date.getTime() - Date.now() };
   }
 
   calculateFutureTime(date, seoncds) {