@cap-js-community/event-queue 0.1.49 → 0.1.51

package/src/runner.js

@@ -3,11 +3,11 @@
 const uuid = require("uuid");
 
 const eventQueueConfig = require("./config");
-const cdsHelper = require("./shared/cdsHelper");
 const { eventQueueRunner } = require("./processEventQueue");
-const distributedLock = require("./shared/distributedLock");
 const { getWorkerPoolInstance } = require("./shared/WorkerQueue");
-const { getConfigInstance } = require("./config");
+const cdsHelper = require("./shared/cdsHelper");
+const distributedLock = require("./shared/distributedLock");
+const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
 
 const COMPONENT_NAME = "eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
@@ -26,17 +26,13 @@ const _scheduleFunction = async (fn) => {
   const configInstance = eventQueueConfig.getConfigInstance();
   const eventsForAutomaticRun = configInstance.events;
   if (!eventsForAutomaticRun.length) {
-    LOGGER.warn(
-      "no events for automatic run are configured - skipping runner registration"
-    );
+    LOGGER.warn("no events for automatic run are configured - skipping runner registration");
     return;
   }
 
   const fnWithRunningCheck = () => {
     if (configInstance.isRunnerDeactivated) {
-      LOGGER.info(
-        "runner is deactivated via config variable. Skipping this run."
-      );
+      LOGGER.info("runner is deactivated via config variable. Skipping this run.");
       return;
     }
     return fn();
@@ -45,14 +41,13 @@ const _scheduleFunction = async (fn) => {
   const offsetDependingOnLastRun = await _calculateOffsetForFirstRun();
 
   LOGGER.info("first event-queue run scheduled", {
-    firstRunScheduledFor: new Date(
-      Date.now() + offsetDependingOnLastRun
-    ).toISOString(),
+    firstRunScheduledFor: new Date(Date.now() + offsetDependingOnLastRun).toISOString(),
   });
 
   setTimeout(() => {
     fnWithRunningCheck();
-    setInterval(fnWithRunningCheck, configInstance.runInterval).unref();
+    const intervalRunner = new SetIntervalDriftSafe(configInstance.runInterval);
+    intervalRunner.run(fnWithRunningCheck);
   }, offsetDependingOnLastRun).unref();
 };
 
@@ -72,9 +67,7 @@ const _multiTenancyRedis = async () => {
 
 const _multiTenancyDb = async () => {
   try {
-    LOGGER.info(
-      "executing event queue run for single instance and multi tenant"
-    );
+    LOGGER.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
     _executeAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
   } catch (err) {
@@ -91,13 +84,9 @@ const _executeAllTenants = (tenantIds, runId) => {
     workerQueueInstance.addToQueue(async () => {
       try {
         const tenantContext = new cds.EventContext({ tenant: tenantId });
-        const couldAcquireLock = await distributedLock.acquireLock(
-          tenantContext,
-          runId,
-          {
-            expiryTime: configInstance.runInterval * 0.95,
-          }
-        );
+        const couldAcquireLock = await distributedLock.acquireLock(tenantContext, runId, {
+          expiryTime: configInstance.runInterval * 0.95,
+        });
         if (!couldAcquireLock) {
           return;
         }
@@ -129,55 +118,38 @@ const _executeRunForTenant = async (tenantId, runId) => {
     });
     await eventQueueRunner(context, eventsForAutomaticRun);
   } catch (err) {
-    LOGGER.error(
-      `Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`,
-      {
-        tenantId,
-        redisEnabled: configInstance.redisEnabled,
-      }
-    );
+    LOGGER.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
+      tenantId,
+      redisEnabled: configInstance.redisEnabled,
+    });
   }
 };
 
 const _acquireRunId = async (context) => {
   const configInstance = eventQueueConfig.getConfigInstance();
   let runId = uuid.v4();
-  const couldSetValue = await distributedLock.setValueWithExpire(
-    context,
-    EVENT_QUEUE_RUN_ID,
-    runId,
-    {
-      tenantScoped: false,
-      expiryTime: configInstance.runInterval * 0.95,
-    }
-  );
+  const couldSetValue = await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_ID, runId, {
+    tenantScoped: false,
+    expiryTime: configInstance.runInterval * 0.95,
+  });
 
   if (couldSetValue) {
-    await distributedLock.setValueWithExpire(
-      context,
-      EVENT_QUEUE_RUN_TS,
-      new Date().toISOString(),
-      {
-        tenantScoped: false,
-        expiryTime: configInstance.runInterval,
-        overrideValue: true,
-      }
-    );
+    await distributedLock.setValueWithExpire(context, EVENT_QUEUE_RUN_TS, new Date().toISOString(), {
+      tenantScoped: false,
+      expiryTime: configInstance.runInterval,
+      overrideValue: true,
+    });
   } else {
-    runId = await distributedLock.checkLockExistsAndReturnValue(
-      context,
-      EVENT_QUEUE_RUN_ID,
-      {
-        tenantScoped: false,
-      }
-    );
+    runId = await distributedLock.checkLockExistsAndReturnValue(context, EVENT_QUEUE_RUN_ID, {
+      tenantScoped: false,
+    });
   }
 
   return runId;
 };
 
 const _calculateOffsetForFirstRun = async () => {
-  const configInstance = getConfigInstance();
+  const configInstance = eventQueueConfig.getConfigInstance();
   let offsetDependingOnLastRun = OFFSET_FIRST_RUN;
   const now = Date.now();
   // NOTE: this is only supported with Redis, because this is a tenant agnostic information
@@ -185,34 +157,24 @@ const _calculateOffsetForFirstRun = async () => {
   try {
     if (configInstance.redisEnabled) {
       const dummyContext = new cds.EventContext({});
-      let lastRunTs = await distributedLock.checkLockExistsAndReturnValue(
-        dummyContext,
-        EVENT_QUEUE_RUN_TS,
-        { tenantScoped: false }
-      );
+      let lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+        tenantScoped: false,
+      });
       if (!lastRunTs) {
         const ts = new Date(now).toISOString();
-        const couldSetValue = await distributedLock.setValueWithExpire(
-          dummyContext,
-          EVENT_QUEUE_RUN_TS,
-          ts,
-          {
-            tenantScoped: false,
-            expiryTime: configInstance.runInterval,
-          }
-        );
+        const couldSetValue = await distributedLock.setValueWithExpire(dummyContext, EVENT_QUEUE_RUN_TS, ts, {
+          tenantScoped: false,
+          expiryTime: configInstance.runInterval,
+        });
         if (couldSetValue) {
           lastRunTs = ts;
         } else {
-          lastRunTs = await distributedLock.checkLockExistsAndReturnValue(
-            dummyContext,
-            EVENT_QUEUE_RUN_TS,
-            { tenantScoped: false }
-          );
+          lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+            tenantScoped: false,
+          });
         }
       }
-      offsetDependingOnLastRun =
-        new Date(lastRunTs).getTime() + configInstance.runInterval - now;
+      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + configInstance.runInterval - now;
     }
   } catch (err) {
     LOGGER.error(

package/src/shared/PerformanceTracer.js

@@ -36,9 +36,7 @@ class PerformanceTracer {
     //determine, if an options object was provided as first argument
     if (
       typeof args?.[0] === "object" &&
-      (args[0].quantity >= 0 ||
-        args[0].threshold > 0 ||
-        args[0].additionalQuantityThreshold > 0)
+      (args[0].quantity >= 0 || args[0].threshold > 0 || args[0].additionalQuantityThreshold > 0)
     ) {
       options = args.shift();
     }

package/src/shared/SetIntervalDriftSafe.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const COMPONENT = "eventQueue/SetIntervalDriftSafe";
+
+class SetIntervalDriftSafe {
+  #adjustedInterval;
+  #interval;
+  #expectedCycleTime = 0;
+  #nextTickScheduledFor;
+  #logger;
+
+  constructor(interval) {
+    this.#interval = interval;
+    this.#adjustedInterval = interval;
+    this.#logger = cds.log(COMPONENT);
+  }
+
+  run(fn) {
+    const now = Date.now();
+    if (this.#expectedCycleTime === 0) {
+      this.#expectedCycleTime = now + this.#interval;
+    } else if (now + this.#interval - this.#nextTickScheduledFor < this.#interval) {
+      this.#logger.info("overlapping ticks, skipping this run");
+      return;
+    } else {
+      this.#adjustedInterval = this.#interval - (now - this.#expectedCycleTime);
+      this.#expectedCycleTime += this.#interval;
+    }
+    this.#nextTickScheduledFor = now + this.#adjustedInterval;
+    setTimeout(() => {
+      this.run(fn);
+      fn();
+    }, this.#adjustedInterval);
+  }
+}
+
+module.exports = SetIntervalDriftSafe;

package/src/shared/WorkerQueue.js

@@ -32,31 +32,20 @@ class WorkerQueue {
     this.__runningPromises.push(promise);
     promise
       .finally(() => {
-        this.__runningPromises.splice(
-          this.__runningPromises.indexOf(promise),
-          1
-        );
+        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! Error:", err);
         reject(err);
       });
   }
 
   _checkForNext() {
-    if (
-      !this.__queue.length ||
-      this.__runningPromises.length >= this.__concurrencyLimit
-    ) {
+    if (!this.__queue.length || this.__runningPromises.length >= this.__concurrencyLimit) {
       return;
     }
     const [cb, resolve, reject] = this.__queue.shift();

package/src/shared/cdsHelper.js

@@ -20,13 +20,7 @@ const COMPONENT_NAME = "eventQueue/cdsHelper";
  * @param info {object} Additional information object attached to logging
  * @returns {Promise<boolean>} Promise resolving to true if everything worked fine / false if an error occurred
  */
-async function executeInNewTransaction(
-  context = {},
-  transactionTag,
-  fn,
-  args,
-  { info = {} } = {}
-) {
+async function executeInNewTransaction(context = {}, transactionTag, fn, args, { info = {} } = {}) {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
   try {
@@ -48,10 +42,7 @@ async function executeInNewTransaction(
     } else {
       const contextTx = cds.tx(context);
       const contextTxState = contextTx.ready;
-      if (
-        !contextTxState ||
-        ["committed", "rolled back"].includes(contextTxState)
-      ) {
+      if (!contextTxState || ["committed", "rolled back"].includes(contextTxState)) {
         await cds.tx(
           {
             id: context.id,

package/src/shared/common.js

@@ -56,10 +56,7 @@ class Funnel {
     }
 
     // map function call to promise
-    const p =
-      f.constructor.name === "AsyncFunction"
-        ? f(...args)
-        : Promise.resolve().then(() => f(...args));
+    const p = f.constructor.name === "AsyncFunction" ? f(...args) : Promise.resolve().then(() => f(...args));
 
     // create promise for book keeping
     const workload = p.finally(() => {
@@ -100,9 +97,7 @@ const limiter = async (limit, payloads, iterator) => {
     returnPromises.push(p);
 
     if (limit <= payloads.length) {
-      const e = p
-        .catch(() => {})
-        .finally(() => runningPromises.splice(runningPromises.indexOf(e), 1));
+      const e = p.catch(() => {}).finally(() => runningPromises.splice(runningPromises.indexOf(e), 1));
       runningPromises.push(e);
       if (limit <= runningPromises.length) {
         await Promise.race(runningPromises);

package/src/shared/distributedLock.js

@@ -8,10 +8,7 @@ const { getConfigInstance } = require("../config");
 const acquireLock = async (
   context,
   key,
-  {
-    tenantScoped = true,
-    expiryTime = config.getConfigInstance().globalTxTimeout,
-  } = {}
+  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
@@ -25,11 +22,7 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  {
-    tenantScoped = true,
-    expiryTime = config.getConfigInstance().globalTxTimeout,
-    overrideValue = false,
-  } = {}
+  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout, overrideValue = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
@@ -54,11 +47,7 @@ const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
   }
 };
 
-const checkLockExistsAndReturnValue = async (
-  context,
-  key,
-  { tenantScoped = true } = {}
-) => {
+const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
     return await _checkLockExistsRedis(context, fullKey);
@@ -67,12 +56,7 @@ const checkLockExistsAndReturnValue = async (
   }
 };
 
-const _acquireLockRedis = async (
-  context,
-  fullKey,
-  expiryTime,
-  { value = "true", overrideValue = false } = {}
-) => {
+const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   const client = await redis.createMainClientAndConnect();
   const result = await client.set(fullKey, value, {
     PX: expiryTime,
@@ -89,17 +73,9 @@ 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)
-      );
-    }
-  );
+  await cdsHelper.executeInNewTransaction(context, "distributedLock-checkExists", async (tx) => {
+    result = await tx.run(SELECT.one.from(configInstance.tableNameEventLock).where("code =", fullKey));
+  });
   return result?.value;
 };
 
@@ -110,69 +86,49 @@ 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 cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
+    await tx.run(DELETE.from(configInstance.tableNameEventLock).where("code =", fullKey));
+  });
 };
 
-const _acquireLockDB = async (
-  context,
-  fullKey,
-  expiryTime,
-  { value = "true", overrideValue = false } = {}
-) => {
+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 cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
+    try {
+      await tx.run(
+        INSERT.into(configInstance.tableNameEventLock).entries({
+          code: fullKey,
+          value,
+        })
+      );
+      result = true;
+    } catch (err) {
+      let currentEntry;
+
+      if (!overrideValue) {
+        currentEntry = await tx.run(
+          SELECT.one
+            .from(configInstance.tableNameEventLock)
+            .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
+            .where("code =", fullKey)
+        );
+      }
+      if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
         await tx.run(
-          INSERT.into(configInstance.tableNameEventLock).entries({
-            code: fullKey,
-            value,
-          })
+          UPDATE.entity(configInstance.tableNameEventLock)
+            .set({
+              createdAt: new Date().toISOString(),
+              value,
+            })
+            .where("code =", currentEntry.code)
         );
         result = true;
-      } catch (err) {
-        let currentEntry;
-
-        if (!overrideValue) {
-          currentEntry = await tx.run(
-            SELECT.one
-              .from(configInstance.tableNameEventLock)
-              .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
-              .where("code =", fullKey)
-          );
-        }
-        if (
-          overrideValue ||
-          (currentEntry &&
-            new Date(currentEntry.createdAt).getTime() + expiryTime <=
-              Date.now())
-        ) {
-          await tx.run(
-            UPDATE.entity(configInstance.tableNameEventLock)
-              .set({
-                createdAt: new Date().toISOString(),
-                value,
-              })
-              .where("code =", currentEntry.code)
-          );
-          result = true;
-        } else {
-          result = false;
-        }
+      } else {
+        result = false;
       }
     }
-  );
+  });
   return result;
 };
 

package/src/shared/redis.js

@@ -15,9 +15,7 @@ const createMainClientAndConnect = () => {
   }
 
   const errorHandlerCreateClient = (err) => {
-    cds
-      .log(COMPONENT_NAME)
-      .error("error from redis client for pub/sub failed", err);
+    cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
     subscriberClientPromise = null;
     setTimeout(createMainClientAndConnect, 5 * 1000).unref();
   };