@cap-js-community/event-queue 1.4.7 → 1.5.1

package/cds-plugin.js

@@ -5,6 +5,6 @@ const cds = require("@sap/cds");
 const eventQueue = require("./src");
 const COMPONENT_NAME = "/eventQueue/plugin";
 
-if (!cds.build.register && cds.env.eventQueue) {
+if (!cds.build?.register && cds.env.eventQueue) {
   module.exports = eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.4.7",
+  "version": "1.5.1",
   "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",
@@ -63,6 +63,9 @@
     "prettier": "^2.8.8",
     "sqlite3": "^5.1.7"
   },
+  "peerDependencies": {
+    "@cap-js/telemetry": "^0.2.2"
+  },
   "homepage": "https://cap-js-community.github.io/event-queue/",
   "repository": {
     "type": "git",

package/src/EventQueueProcessorBase.js

@@ -11,6 +11,7 @@ const eventScheduler = require("./shared/eventScheduler");
 const eventConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
 const { broadcastEvent } = require("./redis/redisPub");
+const trace = require("./shared/openTelemetry");
 
 const IMPLEMENT_ERROR_MESSAGE = "needs to be reimplemented";
 const COMPONENT_NAME = "/eventQueue/EventQueueProcessorBase";
@@ -382,79 +383,81 @@ class EventQueueProcessorBase {
    * The function accepts no arguments as there are dedicated functions to set the status of events (e.g. setEventStatus)
    */
   async persistEventStatus(tx, { skipChecks, statusMap = this.__statusMap } = {}) {
-    this.logger.debug("entering persistEventStatus", {
-      eventType: this.#eventType,
-      eventSubType: this.#eventSubType,
-    });
-    this.#ensureOnlySelectedQueueEntries(statusMap);
-    if (!skipChecks) {
-      this.#ensureEveryQueueEntryHasStatus();
-    }
-    this.#ensureEveryStatusIsAllowed(statusMap);
-
-    const { success, failed, exceeded, invalidAttempts } = Object.entries(statusMap).reduce(
-      (result, [notificationEntityId, processingStatus]) => {
-        this.__commitedStatusMap[notificationEntityId] = processingStatus;
-        if (processingStatus === EventProcessingStatus.Open) {
-          result.invalidAttempts.push(notificationEntityId);
-        } else if (processingStatus === EventProcessingStatus.Done) {
-          result.success.push(notificationEntityId);
-        } else if (processingStatus === EventProcessingStatus.Error) {
-          result.failed.push(notificationEntityId);
-        } else if (processingStatus === EventProcessingStatus.Exceeded) {
-          result.exceeded.push(notificationEntityId);
-        }
-        return result;
-      },
-      {
-        success: [],
-        failed: [],
-        exceeded: [],
-        invalidAttempts: [],
+    return await trace(this.baseContext, "persist-event-status", async () => {
+      this.logger.debug("entering persistEventStatus", {
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+      });
+      this.#ensureOnlySelectedQueueEntries(statusMap);
+      if (!skipChecks) {
+        this.#ensureEveryQueueEntryHasStatus();
       }
-    );
-    this.logger.debug("persistEventStatus for entries", {
-      eventType: this.#eventType,
-      eventSubType: this.#eventSubType,
-      invalidAttempts,
-      failed,
-      exceeded,
-      success,
-    });
-    if (invalidAttempts.length) {
-      await tx.run(
-        UPDATE.entity(this.#config.tableNameEventQueue)
-          .set({
-            status: EventProcessingStatus.Open,
-            lastAttemptTimestamp: new Date().toISOString(),
-            attempts: { "-=": 1 },
-          })
-          .where("ID IN", invalidAttempts)
+      this.#ensureEveryStatusIsAllowed(statusMap);
+
+      const { success, failed, exceeded, invalidAttempts } = Object.entries(statusMap).reduce(
+        (result, [notificationEntityId, processingStatus]) => {
+          this.__commitedStatusMap[notificationEntityId] = processingStatus;
+          if (processingStatus === EventProcessingStatus.Open) {
+            result.invalidAttempts.push(notificationEntityId);
+          } else if (processingStatus === EventProcessingStatus.Done) {
+            result.success.push(notificationEntityId);
+          } else if (processingStatus === EventProcessingStatus.Error) {
+            result.failed.push(notificationEntityId);
+          } else if (processingStatus === EventProcessingStatus.Exceeded) {
+            result.exceeded.push(notificationEntityId);
+          }
+          return result;
+        },
+        {
+          success: [],
+          failed: [],
+          exceeded: [],
+          invalidAttempts: [],
+        }
       );
-    }
-    const ts = new Date().toISOString();
-    const updateTuples = [
-      [success, EventProcessingStatus.Done],
-      [failed, EventProcessingStatus.Error],
-      [exceeded, EventProcessingStatus.Exceeded],
-    ];
-
-    for (const [eventIds, status] of updateTuples) {
-      if (!eventIds.length) {
-        continue;
+      this.logger.debug("persistEventStatus for entries", {
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+        invalidAttempts,
+        failed,
+        exceeded,
+        success,
+      });
+      if (invalidAttempts.length) {
+        await tx.run(
+          UPDATE.entity(this.#config.tableNameEventQueue)
+            .set({
+              status: EventProcessingStatus.Open,
+              lastAttemptTimestamp: new Date().toISOString(),
+              attempts: { "-=": 1 },
+            })
+            .where("ID IN", invalidAttempts)
+        );
       }
-      await tx.run(
-        UPDATE.entity(this.#config.tableNameEventQueue)
-          .set({
-            status: status,
-            lastAttemptTimestamp: ts,
-          })
-          .where("ID IN", eventIds)
-      );
-    }
-    this.logger.debug("exiting persistEventStatus", {
-      eventType: this.#eventType,
-      eventSubType: this.#eventSubType,
+      const ts = new Date().toISOString();
+      const updateTuples = [
+        [success, EventProcessingStatus.Done],
+        [failed, EventProcessingStatus.Error],
+        [exceeded, EventProcessingStatus.Exceeded],
+      ];
+
+      for (const [eventIds, status] of updateTuples) {
+        if (!eventIds.length) {
+          continue;
+        }
+        await tx.run(
+          UPDATE.entity(this.#config.tableNameEventQueue)
+            .set({
+              status: status,
+              lastAttemptTimestamp: ts,
+            })
+            .where("ID IN", eventIds)
+        );
+      }
+      this.logger.debug("exiting persistEventStatus", {
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+      });
     });
   }
 
@@ -728,43 +731,45 @@ class EventQueueProcessorBase {
       return;
     }
 
-    for (const exceededEvent of this.#eventsWithExceededTries) {
-      await executeInNewTransaction(
-        this.context,
-        `eventQueue-handleExceededEvents-${this.#eventType}##${this.#eventSubType}`,
-        async (tx) => {
-          try {
-            this.processEventContext = tx.context;
-            this.modifyQueueEntry(exceededEvent);
-            await this.hookForExceededEvents({ ...exceededEvent });
-            this.logger.warn("The retry attempts for the following events are exceeded", {
-              eventType: this.#eventType,
-              eventSubType: this.#eventSubType,
-              retryAttempts: this.__retryAttempts,
-              queueEntriesId: exceededEvent.ID,
-              currentAttempt: exceededEvent.attempts,
-            });
-            await this.#persistEventQueueStatusForExceeded(this.tx, [exceededEvent], EventProcessingStatus.Exceeded);
-          } catch (err) {
-            this.logger.error(
-              "Caught error during hook for exceeded events - setting queue entry to error. Please catch your promises/exceptions.",
-              err,
-              {
+    return await trace(this.baseContext, "handle-exceeded-events", async () => {
+      for (const exceededEvent of this.#eventsWithExceededTries) {
+        await executeInNewTransaction(
+          this.context,
+          `eventQueue-handleExceededEvents-${this.#eventType}##${this.#eventSubType}`,
+          async (tx) => {
+            try {
+              this.processEventContext = tx.context;
+              this.modifyQueueEntry(exceededEvent);
+              await this.hookForExceededEvents({ ...exceededEvent });
+              this.logger.warn("The retry attempts for the following events are exceeded", {
                 eventType: this.#eventType,
                 eventSubType: this.#eventSubType,
                 retryAttempts: this.__retryAttempts,
                 queueEntriesId: exceededEvent.ID,
                 currentAttempt: exceededEvent.attempts,
-              }
-            );
-            await executeInNewTransaction(this.context, "error-hookForExceededEvents", async (tx) =>
-              this.#persistEventQueueStatusForExceeded(tx, [exceededEvent], EventProcessingStatus.Error)
-            );
-            throw new TriggerRollback();
+              });
+              await this.#persistEventQueueStatusForExceeded(this.tx, [exceededEvent], EventProcessingStatus.Exceeded);
+            } catch (err) {
+              this.logger.error(
+                "Caught error during hook for exceeded events - setting queue entry to error. Please catch your promises/exceptions.",
+                err,
+                {
+                  eventType: this.#eventType,
+                  eventSubType: this.#eventSubType,
+                  retryAttempts: this.__retryAttempts,
+                  queueEntriesId: exceededEvent.ID,
+                  currentAttempt: exceededEvent.attempts,
+                }
+              );
+              await executeInNewTransaction(this.context, "error-hookForExceededEvents", async (tx) =>
+                this.#persistEventQueueStatusForExceeded(tx, [exceededEvent], EventProcessingStatus.Error)
+              );
+              throw new TriggerRollback();
+            }
           }
-        }
-      );
-    }
+        );
+      }
+    });
   }
 
   async #handleExceededTriesExceeded() {
@@ -888,19 +893,21 @@ class EventQueueProcessorBase {
       return true;
     }
 
-    const lockAcquired = await distributedLock.acquireLock(
-      this.context,
-      [this.#eventType, this.#eventSubType].join("##")
-    );
-    if (!lockAcquired) {
-      this.logger.debug("no lock available, exit processing", {
-        type: this.#eventType,
-        subType: this.#eventSubType,
-      });
-      return false;
-    }
-    this.__lockAcquired = true;
-    return true;
+    return await trace(this.baseContext, "acquire-lock", async () => {
+      const lockAcquired = await distributedLock.acquireLock(
+        this.context,
+        [this.#eventType, this.#eventSubType].join("##")
+      );
+      if (!lockAcquired) {
+        this.logger.debug("no lock available, exit processing", {
+          type: this.#eventType,
+          subType: this.#eventSubType,
+        });
+        return false;
+      }
+      this.__lockAcquired = true;
+      return true;
+    });
   }
 
   async handleReleaseLock() {
@@ -908,7 +915,9 @@ class EventQueueProcessorBase {
       return;
     }
     try {
-      await distributedLock.releaseLock(this.context, [this.#eventType, this.#eventSubType].join("##"));
+      await trace(this.baseContext, "persist-release-lock", async () => {
+        await distributedLock.releaseLock(this.context, [this.#eventType, this.#eventSubType].join("##"));
+      });
     } catch (err) {
       this.logger.error("Releasing distributed lock failed.", err);
     }

package/src/config.js

@@ -68,6 +68,7 @@ class Config {
   #cleanupLocksAndEventsForDev;
   #redisOptions;
   #insertEventsBeforeCommit;
+  #enableCAPTelemetry;
   #unsubscribeHandlers = [];
   #unsubscribedTenants = {};
   static #instance;
@@ -555,6 +556,14 @@ class Config {
     return this.#insertEventsBeforeCommit;
   }
 
+  set enableCAPTelemetry(value) {
+    this.#enableCAPTelemetry = value;
+  }
+
+  get enableCAPTelemetry() {
+    return this.#enableCAPTelemetry;
+  }
+
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }

package/src/index.d.ts

@@ -116,18 +116,24 @@ export declare class EventQueueProcessorBase {
   getTxForEventProcessing(key: string): cds.Transaction;
   setShouldRollbackTransaction(key: string): void;
   shouldRollbackTransaction(key: string): boolean;
+  beforeProcessingEvents(): Promise<void>;
 
   set logger(value: CdsLogger);
   get logger(): CdsLogger;
   get tx(): cds.Transaction;
   get context(): cds.EventContext;
   get isPeriodicEvent(): boolean;
+  get eventType(): String;
+  get eventSubType(): String;
 }
 
 export function publishEvent(
   tx: cds.Transaction,
   events: EventEntityPublish[] | EventEntityPublish,
-  skipBroadcast?: boolean
+  options?: {
+    skipBroadcast?: boolean;
+    skipInsertEventsBeforeCommit?: boolean;
+  }
 ): Promise<any>;
 
 export function processEventQueue(

package/src/initialize.js

@@ -36,6 +36,7 @@ const CONFIG_VARS = [
   ["cleanupLocksAndEventsForDev", false],
   ["redisOptions", {}],
   ["insertEventsBeforeCommit", false],
+  ["enableCAPTelemetry", false],
 ];
 
 const initialize = async ({
@@ -52,6 +53,7 @@ const initialize = async ({
   cleanupLocksAndEventsForDev,
   redisOptions,
   insertEventsBeforeCommit,
+  enableCAPTelemetry,
 } = {}) => {
   if (config.initialized) {
     return;
@@ -71,7 +73,8 @@ const initialize = async ({
     userId,
     cleanupLocksAndEventsForDev,
     redisOptions,
-    insertEventsBeforeCommit
+    insertEventsBeforeCommit,
+    enableCAPTelemetry
   );
 
   const logger = cds.log(COMPONENT);

package/src/processEventQueue.js

@@ -9,6 +9,7 @@ const { TransactionMode, EventProcessingStatus } = require("./constants");
 const { limiter } = require("./shared/common");
 
 const { executeInNewTransaction, TriggerRollback } = require("./shared/cdsHelper");
+const trace = require("./shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/processEventQueue";
 
@@ -44,26 +45,28 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
       iterationCounter++;
       await executeInNewTransaction(context, `eventQueue-pre-processing-${eventType}##${eventSubType}`, async (tx) => {
         eventTypeInstance = new EventTypeClass(tx.context, eventType, eventSubType, eventConfig);
-        const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
-        eventTypeInstance.startPerformanceTracerPreprocessing();
-        for (const queueEntry of queueEntries) {
-          try {
-            eventTypeInstance.modifyQueueEntry(queueEntry);
-            const payload = await eventTypeInstance.checkEventAndGeneratePayload(queueEntry);
-            if (payload === null) {
-              eventTypeInstance.setStatusToDone(queueEntry);
-              continue;
-            }
-            if (payload === undefined) {
-              eventTypeInstance.handleInvalidPayloadReturned(queueEntry);
-              continue;
+        await trace(eventTypeInstance.context, "preparation", async () => {
+          const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
+          eventTypeInstance.startPerformanceTracerPreprocessing();
+          for (const queueEntry of queueEntries) {
+            try {
+              eventTypeInstance.modifyQueueEntry(queueEntry);
+              const payload = await eventTypeInstance.checkEventAndGeneratePayload(queueEntry);
+              if (payload === null) {
+                eventTypeInstance.setStatusToDone(queueEntry);
+                continue;
+              }
+              if (payload === undefined) {
+                eventTypeInstance.handleInvalidPayloadReturned(queueEntry);
+                continue;
+              }
+              eventTypeInstance.addEventWithPayloadForProcessing(queueEntry, payload);
+            } catch (err) {
+              eventTypeInstance.handleErrorDuringProcessing(err, queueEntry);
             }
-            eventTypeInstance.addEventWithPayloadForProcessing(queueEntry, payload);
-          } catch (err) {
-            eventTypeInstance.handleErrorDuringProcessing(err, queueEntry);
           }
-        }
-        throw new TriggerRollback();
+          throw new TriggerRollback();
+        });
       });
       await eventTypeInstance.handleExceededEvents();
       if (!eventTypeInstance) {
@@ -73,20 +76,22 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
       if (Object.keys(eventTypeInstance.queueEntriesWithPayloadMap).length) {
         await executeInNewTransaction(context, `eventQueue-processing-${eventType}##${eventSubType}`, async (tx) => {
           eventTypeInstance.processEventContext = tx.context;
-          try {
-            eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
-            await processEventMap(eventTypeInstance);
-          } catch (err) {
-            eventTypeInstance.handleErrorDuringClustering(err);
-          }
-          if (
-            eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
-            Object.entries(eventTypeInstance.eventProcessingMap).some(([key]) =>
-              eventTypeInstance.shouldRollbackTransaction(key)
-            )
-          ) {
-            throw new TriggerRollback();
-          }
+          await trace(eventTypeInstance.context, "process-events", async () => {
+            try {
+              eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
+              await processEventMap(eventTypeInstance);
+            } catch (err) {
+              eventTypeInstance.handleErrorDuringClustering(err);
+            }
+            if (
+              eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
+              Object.entries(eventTypeInstance.eventProcessingMap).some(([key]) =>
+                eventTypeInstance.shouldRollbackTransaction(key)
+              )
+            ) {
+              throw new TriggerRollback();
+            }
+          });
         });
       }
       await executeInNewTransaction(context, `eventQueue-persistStatus-${eventType}##${eventSubType}`, async (tx) => {
@@ -128,17 +133,19 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
         eventTypeInstance.context,
         `eventQueue-periodic-scheduleNext-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
         async (tx) => {
-          eventTypeInstance.processEventContext = tx.context;
-          const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
-          if (!queueEntries.length) {
-            return;
-          }
-          if (queueEntries.length > 1) {
-            queueEntry = await eventTypeInstance.handleDuplicatedPeriodicEventEntry(queueEntries);
-          } else {
-            queueEntry = queueEntries[0];
-          }
-          processNext = await eventTypeInstance.scheduleNextPeriodEvent(queueEntry);
+          await trace(eventTypeInstance.context, "periodic-event-preparation", async () => {
+            eventTypeInstance.processEventContext = tx.context;
+            const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
+            if (!queueEntries.length) {
+              return;
+            }
+            if (queueEntries.length > 1) {
+              queueEntry = await eventTypeInstance.handleDuplicatedPeriodicEventEntry(queueEntries);
+            } else {
+              queueEntry = queueEntries[0];
+            }
+            processNext = await eventTypeInstance.scheduleNextPeriodEvent(queueEntry);
+          });
         }
       );
 
@@ -151,24 +158,26 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
         eventTypeInstance.context,
         `eventQueue-periodic-process-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
         async (tx) => {
-          eventTypeInstance.processEventContext = tx.context;
-          eventTypeInstance.setTxForEventProcessing(queueEntry.ID, cds.tx(tx.context));
-          try {
-            eventTypeInstance.startPerformanceTracerPeriodicEvents();
-            await eventTypeInstance.processPeriodicEvent(tx.context, queueEntry.ID, queueEntry);
-          } catch (err) {
-            status = EventProcessingStatus.Error;
-            eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
-            throw new TriggerRollback();
-          } finally {
-            eventTypeInstance.endPerformanceTracerPeriodicEvents();
-          }
-          if (
-            eventTypeInstance.transactionMode === TransactionMode.alwaysRollback ||
-            eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
-          ) {
-            throw new TriggerRollback();
-          }
+          await trace(eventTypeInstance.context, "process-periodic-event", async () => {
+            eventTypeInstance.processEventContext = tx.context;
+            eventTypeInstance.setTxForEventProcessing(queueEntry.ID, cds.tx(tx.context));
+            try {
+              eventTypeInstance.startPerformanceTracerPeriodicEvents();
+              await eventTypeInstance.processPeriodicEvent(tx.context, queueEntry.ID, queueEntry);
+            } catch (err) {
+              status = EventProcessingStatus.Error;
+              eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
+              throw new TriggerRollback();
+            } finally {
+              eventTypeInstance.endPerformanceTracerPeriodicEvents();
+            }
+            if (
+              eventTypeInstance.transactionMode === TransactionMode.alwaysRollback ||
+              eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
+            ) {
+              throw new TriggerRollback();
+            }
+          });
         }
       );
 
@@ -176,8 +185,10 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
         eventTypeInstance.context,
         `eventQueue-periodic-setStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
         async (tx) => {
-          eventTypeInstance.processEventContext = tx.context;
-          await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID, status);
+          await trace(eventTypeInstance.context, "periodic-event-set-status", async () => {
+            eventTypeInstance.processEventContext = tx.context;
+            await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID, status);
+          });
         }
       );
     }
@@ -186,8 +197,6 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
       eventType: eventTypeInstance?.eventType,
       eventSubType: eventTypeInstance?.eventSubType,
     });
-  } finally {
-    await eventTypeInstance?.handleReleaseLock();
   }
 };
 

package/src/publishEvent.js

@@ -21,13 +21,15 @@ const EventQueueError = require("./EventQueueError");
  *     createdAt: Timestamp, // Timestamp of event creation. This field is automatically set on insert.
  *     startAfter: Timestamp, // Timestamp indicating when the event should start after.
  *   }
- * @param {Boolean} skipBroadcast - (Optional) If set to true, event broadcasting will be skipped. Defaults to false.
+ * @param {Object} [options] - Optional settings.
+ * @param {Boolean} [options.skipBroadcast=false] - If set to true, event broadcasting will be skipped. Defaults to false.
+ * @param {Boolean} [options.skipInsertEventsBeforeCommit=false] - If set to true, events will not be inserted before the transaction commit. Defaults to false.
  * @throws {EventQueueError} Throws an error if the configuration is not initialized.
  * @throws {EventQueueError} Throws an error if the event type is unknown.
  * @throws {EventQueueError} Throws an error if the startAfter field is not a valid date.
- * @returns {Promise} Returns a promise which resolves to the result of the database insert operation.
+ * @returns {Promise<*>} Returns a promise which resolves to the result of the database insert operation.
  */
-const publishEvent = async (tx, events, skipBroadcast = false) => {
+const publishEvent = async (tx, events, { skipBroadcast = false, skipInsertEventsBeforeCommit = false } = {}) => {
   if (!config.initialized) {
     throw EventQueueError.notInitialized();
   }
@@ -46,11 +48,12 @@ const publishEvent = async (tx, events, skipBroadcast = false) => {
     }
   }
 
-  if (config.insertEventsBeforeCommit) {
+  if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);
   } else {
+    let result;
     tx._skipEventQueueBroadcase = skipBroadcast;
-    const result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(eventsForProcessing));
+    result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(events));
     tx._skipEventQueueBroadcase = false;
     return result;
   }

package/src/redis/redisPub.js

@@ -40,7 +40,7 @@ const broadcastEvent = async (tenantId, events) => {
 
         return await cds.tx(context, async ({ context }) => {
           for (const { type, subType } of events) {
-            await runEventCombinationForTenant(context, type, subType);
+            await runEventCombinationForTenant(context, type, subType, { shouldTrace: true });
           }
         });
       }
@@ -75,7 +75,7 @@ const broadcastEvent = async (tenantId, events) => {
         await redis.publishMessage(
           config.redisOptions,
           EVENT_MESSAGE_CHANNEL,
-          JSON.stringify({ tenantId, type, subType })
+          JSON.stringify({ lockId: cds.utils.uuid(), tenantId, type, subType })
         );
         break;
       }

package/src/redis/redisSub.js

@@ -21,7 +21,7 @@ const initEventQueueRedisSubscribe = () => {
 const _messageHandlerProcessEvents = async (messageData) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const { tenantId, type, subType } = JSON.parse(messageData);
+    const { lockId, tenantId, type, subType } = JSON.parse(messageData);
     logger.debug("received redis event", {
       tenantId,
       type,
@@ -65,7 +65,7 @@ const _messageHandlerProcessEvents = async (messageData) => {
     }
 
     return await cds.tx(tenantContext, async ({ context }) => {
-      return await runnerHelper.runEventCombinationForTenant(context, type, subType);
+      return await runnerHelper.runEventCombinationForTenant(context, type, subType, { lockId, shouldTrace: true });
     });
   } catch (err) {
     logger.error("could not parse event information", {

package/src/runner/runner.js

@@ -15,6 +15,7 @@ const config = require("../config");
 const redisPub = require("../redis/redisPub");
 const openEvents = require("./openEvents");
 const { runEventCombinationForTenant } = require("./runnerHelper");
+const trace = require("../shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
@@ -79,6 +80,13 @@ const _multiTenancyRedis = async () => {
 };
 
 const _checkPeriodicEventUpdate = async (tenantIds) => {
+  if (!eventQueueConfig.updatePeriodicEvents || !eventQueueConfig.periodicEvents.length) {
+    cds.log(COMPONENT_NAME).info("updating of periodic events is disabled or no periodic events configured", {
+      updateEnabled: eventQueueConfig.updatePeriodicEvents,
+      events: eventQueueConfig.periodicEvents.length,
+    });
+    return;
+  }
   const hash = common.hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
@@ -101,31 +109,48 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
     // NOTE: do checks for all tenants on the same app instance --> acquire lock tenant independent
     //       distribute from this instance to all others
     const dummyContext = new cds.EventContext({});
-    const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_RUN_REDIS_CHECK, {
-      expiryTime: eventQueueConfig.runInterval * 0.95,
-      tenantScoped: false,
-    });
+    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;
     }
 
     for (const tenantId of tenantIds) {
       await cds.tx({ tenant: tenantId }, async (tx) => {
-        tx.context.user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
-        const entries = await openEvents.getOpenQueueEntries(tx);
-        logger.info("broadcasting events for run", {
-          tenantId,
-          entries: entries.length,
-        });
-        if (!entries.length) {
-          return;
-        }
-        await redisPub.broadcastEvent(tenantId, entries).catch((err) => {
-          logger.error("broadcasting event failed", err, {
-            tenantId,
-            entries: entries.length,
-          });
-        });
+        await trace(
+          tx.context,
+          "get-openEvents-and-publish",
+          async () => {
+            tx.context.user = new cds.User.Privileged({
+              id: config.userId,
+              authInfo: await common.getAuthInfo(tenantId),
+            });
+            const entries = await openEvents.getOpenQueueEntries(tx);
+            logger.info("broadcasting events for run", {
+              tenantId,
+              entries: entries.length,
+            });
+            if (!entries.length) {
+              return;
+            }
+            await redisPub.broadcastEvent(tenantId, entries).catch((err) => {
+              logger.error("broadcasting event failed", err, {
+                tenantId,
+                entries: entries.length,
+              });
+            });
+          },
+          { newRootSpan: true }
+        );
       });
     }
   } catch (err) {
@@ -137,16 +162,25 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
   const promises = [];
 
   for (const tenantId of tenantIds) {
-    const user = await cds.tx({ tenant: tenantId }, async () => {
-      return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
-    });
-    const tenantContext = {
-      tenant: tenantId,
-      user,
-    };
-    const events = await cds.tx(tenantContext, async (tx) => {
-      return await openEvents.getOpenQueueEntries(tx);
-    });
+    const id = cds.utils.uuid();
+    let tenantContext;
+    const events = await trace(
+      { id, tenant: tenantId },
+      "fetch-openEvents-and-authInfo",
+      async () => {
+        const user = await cds.tx({ tenant: tenantId }, async () => {
+          return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+        });
+        tenantContext = {
+          tenant: tenantId,
+          user,
+        };
+        return await cds.tx(tenantContext, async (tx) => {
+          return await openEvents.getOpenQueueEntries(tx);
+        });
+      },
+      { newRootSpan: true }
+    );
 
     if (!events.length) {
       continue;
@@ -158,20 +192,29 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
         const label = `${eventConfig.type}_${eventConfig.subType}`;
         return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
           return await cds.tx(tenantContext, async ({ context }) => {
-            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, true);
-            } catch (err) {
-              cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-                tenantId,
-              });
-            }
+            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,
+                  });
+                }
+              },
+              { newRootSpan: true }
+            );
           });
         });
       })
@@ -191,15 +234,17 @@ const _executePeriodicEventsAllTenants = async (tenantIds) => {
         user,
       };
       await cds.tx(tenantContext, async ({ context }) => {
-        if (!config.redisEnabled) {
-          const couldAcquireLock = await distributedLock.acquireLock(context, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
-            expiryTime: eventQueueConfig.runInterval * 0.95,
-          });
-          if (!couldAcquireLock) {
-            return;
+        await trace(tenantContext, "update-periodic-events-for-tenant", async () => {
+          if (!config.redisEnabled) {
+            const couldAcquireLock = await distributedLock.acquireLock(context, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+              expiryTime: eventQueueConfig.runInterval * 0.95,
+            });
+            if (!couldAcquireLock) {
+              return;
+            }
           }
-        }
-        await _checkPeriodicEventsSingleTenant(context);
+          await _checkPeriodicEventsSingleTenant(context);
+        });
       });
     } catch (err) {
       cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
@@ -268,28 +313,30 @@ const _calculateOffsetForFirstRun = async () => {
   const now = Date.now();
   // NOTE: this is only supported with Redis, because this is a tenant agnostic information
   //       currently there is no proper place to store this information beside t0 schema
+  const dummyContext = new cds.EventContext({});
   try {
-    if (eventQueueConfig.redisEnabled) {
-      const dummyContext = new cds.EventContext({});
-      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, {
+    await trace(dummyContext, "calculateOffsetForFirstRun", async () => {
+      if (eventQueueConfig.redisEnabled) {
+        let lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
           tenantScoped: false,
-          expiryTime: eventQueueConfig.runInterval,
         });
-        if (couldSetValue) {
-          lastRunTs = ts;
-        } else {
-          lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+        if (!lastRunTs) {
+          const ts = new Date(now).toISOString();
+          const couldSetValue = await distributedLock.setValueWithExpire(dummyContext, EVENT_QUEUE_RUN_TS, ts, {
             tenantScoped: false,
+            expiryTime: eventQueueConfig.runInterval,
           });
+          if (couldSetValue) {
+            lastRunTs = ts;
+          } else {
+            lastRunTs = await distributedLock.checkLockExistsAndReturnValue(dummyContext, EVENT_QUEUE_RUN_TS, {
+              tenantScoped: false,
+            });
+          }
         }
+        offsetDependingOnLastRun = new Date(lastRunTs).getTime() + eventQueueConfig.runInterval - now;
       }
-      offsetDependingOnLastRun = new Date(lastRunTs).getTime() + eventQueueConfig.runInterval - now;
-    }
+    });
   } catch (err) {
     cds
       .log(COMPONENT_NAME)
@@ -315,19 +362,26 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
   try {
     logger.info("executing event queue update periodic events");
 
-    if (config.redisEnabled) {
-      const dummyContext = new cds.EventContext({});
-      const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
-        expiryTime: 60 * 1000, // short living lock --> assume we do not have 2 onboards within 1 minute
-        tenantScoped: false,
-      });
-      if (!couldAcquireLock) {
-        return;
-      }
-    }
+    const dummyContext = new cds.EventContext({});
+    return await trace(
+      dummyContext,
+      "update-periodic-events",
+      async () => {
+        if (config.redisEnabled) {
+          const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+            expiryTime: 60 * 1000, // short living lock --> assume we do not have 2 onboards within 1 minute
+            tenantScoped: false,
+          });
+          if (!couldAcquireLock) {
+            return;
+          }
+        }
 
-    tenantIds = tenantIds ?? (await cdsHelper.getAllTenantIds());
-    return await _executePeriodicEventsAllTenants(tenantIds);
+        tenantIds = tenantIds ?? (await cdsHelper.getAllTenantIds());
+        return await _executePeriodicEventsAllTenants(tenantIds);
+      },
+      { newRootSpan: true }
+    );
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for updating periodic event processing!", err);
   }

package/src/runner/runnerHelper.js

@@ -7,10 +7,12 @@ const cds = require("@sap/cds");
 const { processEventQueue } = require("../processEventQueue");
 const eventQueueConfig = require("../config");
 const WorkerQueue = require("../shared/WorkerQueue");
+const distributedLock = require("../shared/distributedLock");
+const trace = require("../shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/runnerHelper";
 
-const runEventCombinationForTenant = async (context, type, subType, skipWorkerPool) => {
+const runEventCombinationForTenant = async (context, type, subType, { skipWorkerPool, lockId, shouldTrace } = {}) => {
   try {
     if (skipWorkerPool) {
       return await processEventQueue(context, type, subType);
@@ -21,7 +23,23 @@ const runEventCombinationForTenant = async (context, type, subType, skipWorkerPo
         eventConfig.load,
         label,
         eventConfig.priority,
-        AsyncResource.bind(async () => await processEventQueue(context, type, subType))
+        AsyncResource.bind(async () => {
+          const _exec = async () => {
+            if (lockId) {
+              const lockAvailable = await distributedLock.acquireLock(context, lockId);
+              if (!lockAvailable) {
+                return;
+              }
+            }
+
+            await processEventQueue(context, type, subType);
+          };
+          if (shouldTrace) {
+            return await trace(context, label, _exec, { newRootSpan: true });
+          } else {
+            return await _exec();
+          }
+        })
       );
     }
   } catch (err) {

package/src/shared/eventScheduler.js

@@ -27,7 +27,10 @@ class EventScheduler {
       subType,
       delaySeconds: (date.getTime() - Date.now()) / 1000,
     });
-    setTimeout(() => {
+    this.#eventsByTenants[tenantId] ??= {};
+    let timeoutId;
+    const timeout = setTimeout(() => {
+      delete this.#eventsByTenants[tenantId][timeoutId];
       delete this.#scheduledEvents[key];
       redisPub.broadcastEvent(tenantId, { type, subType }).catch((err) => {
         cds.log(COMPONENT_NAME).error("could not execute scheduled event", err, {
@@ -38,9 +41,16 @@ class EventScheduler {
         });
       });
     }, relative).unref();
+    // Convert the timeout object to a primitive timeout id to avoid circular dependencies between the callback of setTimeout
+    // and the closure. The usage of the timeout object in the callback, leads to a deadlock for the garbage collector
+    // as the timeout object has a reference to the callback of setTimeout.
+    timeoutId = String(timeout);
+    this.#eventsByTenants[tenantId][timeoutId] = true;
   }
 
-  clearForTenant() {}
+  clearForTenant(tenantId) {
+    Object.values(this.#eventsByTenants[tenantId]).forEach((timeoutId) => clearTimeout(timeoutId));
+  }
 
   calculateOffset(type, subType, startAfter) {
     const eventConfig = config.getEventConfig(type, subType);

package/src/shared/openTelemetry.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const cds = require("@sap/cds");
+let otel;
+try {
+  otel = require("@opentelemetry/api");
+} catch {
+  // ignore
+}
+
+const config = require("../config");
+
+const trace = async (context, label, fn, { attributes = {}, newRootSpan = false } = {}) => {
+  if (!config.enableCAPTelemetry || !otel || !cds._telemetry?.tracer) {
+    return fn();
+  }
+
+  const span = cds._telemetry.tracer.startSpan(`eventqueue-${label}`, {
+    kind: otel.SpanKind.INTERNAL,
+    root: newRootSpan,
+  });
+  _setAttributes(context, span, attributes);
+  const ctxWithSpan = otel.trace.setSpan(otel.context.active(), span);
+  return otel.context.with(ctxWithSpan, async () => {
+    const onSuccess = (res) => {
+      span.setStatus({ code: otel.SpanStatusCode.OK });
+      return res;
+    };
+    const onFailure = (e) => {
+      span.recordException(e);
+      span.setStatus(
+        Object.assign({ code: otel.SpanStatusCode.ERROR }, e.message ? { message: e.message } : undefined)
+      );
+      throw e;
+    };
+    const onDone = () => {
+      if (span.status.code !== otel.SpanStatusCode.UNSET && !span.ended) {
+        span.end();
+      }
+    };
+
+    try {
+      const res = fn();
+      if (res instanceof Promise) {
+        return res.then(onSuccess).catch(onFailure).finally(onDone);
+      }
+      return onSuccess(res);
+    } catch (e) {
+      onFailure(e);
+    } finally {
+      onDone();
+    }
+  });
+};
+
+const _setAttributes = (context, span, attributes) => {
+  span.setAttribute("sap.tenancy.tenant_id", context.tenant);
+  span.setAttribute("sap.correlation_id", context.id);
+  for (const attributeKey in attributes) {
+    span.setAttribute(attributeKey, attributes[attributeKey]);
+  }
+};
+
+module.exports = trace;