@cap-js-community/event-queue 1.9.1 → 1.9.2

package/db/Event.cds

@@ -23,4 +23,6 @@ entity Event: cuid {
     lastAttemptTimestamp: Timestamp;
     createdAt: Timestamp @cds.on.insert : $now;
     startAfter: Timestamp;
+    context: LargeString;
+    error: String;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.9.1",
+  "version": "1.9.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",
@@ -44,16 +44,17 @@
   },
   "dependencies": {
     "@sap/xssec": "^4.2.4",
-    "cron-parser": "^4.9.0",
+    "cron-parser": "^5.0.0",
     "redis": "^4.7.0",
     "verror": "^1.10.1",
     "yaml": "^2.6.1"
   },
   "devDependencies": {
-    "@cap-js/hana": "^1.5.2",
-    "@cap-js/sqlite": "^1.7.8",
-    "@sap/cds": "^8.6.0",
-    "@sap/cds-dk": "^8.6.1",
+    "@cap-js/cds-test": "^0.2.0",
+    "@cap-js/hana": "^1.7.0",
+    "@cap-js/sqlite": "^1.9.0",
+    "@sap/cds": "^8.8.0",
+    "@sap/cds-dk": "^8.8.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",
@@ -62,7 +63,8 @@
     "hdb": "^0.19.10",
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "@opentelemetry/api": "^1.9.0"
   },
   "homepage": "https://cap-js-community.github.io/event-queue/",
   "repository": {

package/src/EventQueueProcessorBase.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const cds = require("@sap/cds");
-const cronParser = require("cron-parser");
+const { CronExpressionParser } = require("cron-parser");
 
 const { executeInNewTransaction } = require("./shared/cdsHelper");
 const { EventProcessingStatus, TransactionMode } = require("./constants");
@@ -11,7 +11,7 @@ const { arrayToFlatMap } = require("./shared/common");
 const eventScheduler = require("./shared/eventScheduler");
 const eventConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
-const trace = require("./shared/openTelemetry");
+const { trace } = require("./shared/openTelemetry");
 const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
 
 const IMPLEMENT_ERROR_MESSAGE = "needs to be reimplemented";
@@ -66,7 +66,6 @@ class EventQueueProcessorBase {
     }
     this.#retryFailedAfter = this.#eventConfig.retryFailedAfter ?? DEFAULT_RETRY_AFTER;
     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;
     this.__selectNextChunk = !!this.#eventConfig.checkForNextChunk;
@@ -331,6 +330,11 @@ class EventQueueProcessorBase {
     } catch {
       /* empty */
     }
+    try {
+      queueEntry.context = JSON.parse(queueEntry.context);
+    } catch {
+      /* empty */
+    }
   }
 
   #determineAndAddEventStatusToMap(id, processingStatus, statusMap = this.__statusMap) {
@@ -602,7 +606,7 @@ class EventQueueProcessorBase {
             " ) AND ( status =",
             EventProcessingStatus.Open,
             "AND ( lastAttemptTimestamp <=",
-            this.__startTime.toISOString(),
+            this.startTime.toISOString(),
             ...(this.isPeriodicEvent
               ? [
                   "OR lastAttemptTimestamp IS NULL ) OR ( status =",
@@ -615,7 +619,7 @@ class EventQueueProcessorBase {
                   "OR lastAttemptTimestamp IS NULL ) OR ( status =",
                   EventProcessingStatus.Error,
                   "AND lastAttemptTimestamp <=",
-                  this.__startTime.toISOString(),
+                  this.startTime.toISOString(),
                   ") OR ( status =",
                   EventProcessingStatus.InProgress,
                   "AND lastAttemptTimestamp <=",
@@ -859,7 +863,12 @@ class EventQueueProcessorBase {
   }
 
   continuesKeepAlive() {
-    this.#keepAliveRunner.run(async () => {
+    if (Date.now() - this.lockAcquiredTime.getTime() >= this.#eventConfig.keepAliveInterval) {
+      trace(this.baseContext, "keepAlive-between-iterations", async () => {
+        await this.#renewDistributedLock();
+      }).catch((err) => this.logger.error("renewing lock between intervals failed!", err));
+    }
+    this.#keepAliveRunner.start(async () => {
       await this.#currentKeepAlivePromise;
       this.#currentKeepAlivePromise = executeInNewTransaction(this.__baseContext, "keepAlive", async (tx) => {
         await trace(tx.context, "keepAlive", async () => {
@@ -978,6 +987,7 @@ class EventQueueProcessorBase {
       });
       return false;
     }
+    this.lockAcquiredTime = new Date();
     return true;
   }
 
@@ -1000,9 +1010,8 @@ class EventQueueProcessorBase {
     }
 
     // NOTE: do not pass current date as we always want to calc. a future date
-    const cronExpression = cronParser.parseExpression(this.#eventConfig.cron, {
-      utc: this.#eventConfig.utc,
-      ...(this.#eventConfig.useCronTimezone && { tz: this.#config.cronTimezone }),
+    const cronExpression = CronExpressionParser.parse(this.#eventConfig.cron, {
+      tz: eventConfig.tz,
     });
     return cronExpression.next();
   }
@@ -1247,6 +1256,22 @@ class EventQueueProcessorBase {
   get eventConfig() {
     return this.#eventConfig;
   }
+
+  get lockAcquiredTime() {
+    return this.#eventConfig.lockAcquiredTime;
+  }
+
+  get startTime() {
+    return this.#eventConfig.startTime;
+  }
+
+  set lockAcquiredTime(value) {
+    this.#eventConfig.lockAcquiredTime = value;
+  }
+
+  get inheritTraceContext() {
+    return this.#eventConfig.inheritTraceContext;
+  }
 }
 
 module.exports = EventQueueProcessorBase;

package/src/config.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const cds = require("@sap/cds");
-const cronParser = require("cron-parser");
+const { CronExpressionParser } = require("cron-parser");
 
 const { getEnvInstance } = require("./shared/env");
 const redis = require("./shared/redis");
@@ -20,6 +20,7 @@ const DEFAULT_PRIORITY = Priorities.Medium;
 const DEFAULT_INCREASE_PRIORITY = true;
 const DEFAULT_KEEP_ALIVE_INTERVAL = 60;
 const DEFAULT_MAX_FACTOR_STUCK_2_KEEP_ALIVE_INTERVAL = 3.5;
+const DEFAULT_INHERIT_TRACE_CONTEXT = true;
 const SUFFIX_PERIODIC = "_PERIODIC";
 const COMMAND_BLOCK = "EVENT_QUEUE_EVENT_BLOCK";
 const COMMAND_UNBLOCK = "EVENT_QUEUE_EVENT_UNBLOCK";
@@ -62,7 +63,7 @@ class Config {
   #cleanupLocksAndEventsForDev;
   #redisOptions;
   #insertEventsBeforeCommit;
-  #enableCAPTelemetry;
+  #enableTelemetry;
   #unsubscribeHandlers = [];
   #unsubscribedTenants = {};
   #cronTimezone;
@@ -93,7 +94,9 @@ class Config {
   }
 
   getEventConfig(type, subType) {
-    return this.#eventMap[this.generateKey(type, subType)];
+    return this.#eventMap[this.generateKey(type, subType)]
+      ? { ...this.#eventMap[this.generateKey(type, subType)] }
+      : undefined;
   }
 
   isCapOutboxEvent(type) {
@@ -311,6 +314,7 @@ class Config {
       multiInstanceProcessing: config.multiInstanceProcessing,
       increasePriorityOverTime: config.increasePriorityOverTime,
       keepAliveInterval: config.keepAliveInterval,
+      inheritTraceContext: true,
       internalEvent: true,
     };
 
@@ -461,10 +465,23 @@ class Config {
 
     if (event.cron) {
       let cron;
+
+      // NOTE: logic is as follows:
+      // - if event.utc is true --> always use UTC
+      // - if event.useCronTimezone is false OR event.cronTimezone is not defined --> use UTC as well
+      // - if event.utc is not true AND event.cronTimezone is set AND event.useCronTimezone is NOT set to false use event.cronTimezone
       event.utc = event.utc ?? UTC_DEFAULT;
-      event.useCronTimezone = event.useCronTimezone ?? USE_CRON_TZ_DEFAULT;
+
+      if (!event.cronTimezone) {
+        event.useCronTimezone = false;
+      } else {
+        event.useCronTimezone = event.useCronTimezone ?? USE_CRON_TZ_DEFAULT;
+      }
+
+      event.tz = event.utc || !event.useCronTimezone ? "UTC" : event.cronTimezone;
+
       try {
-        cron = cronParser.parseExpression(event.cron);
+        cron = CronExpressionParser.parse(event.cron);
       } catch {
         throw EventQueueError.cantParseCronExpression(event.type, event.subType, event.cron);
       }
@@ -497,6 +514,7 @@ class Config {
     if (this.isMultiTenancy && event.multiInstanceProcessing) {
       throw EventQueueError.multiInstanceProcessingNotAllowed(event.type, event.subType);
     }
+    event.inheritTraceContext = event.inheritTraceContext ?? DEFAULT_INHERIT_TRACE_CONTEXT;
 
     this.#basicEventValidation(event);
   }
@@ -744,18 +762,22 @@ class Config {
     return this.#insertEventsBeforeCommit;
   }
 
-  set enableCAPTelemetry(value) {
-    this.#enableCAPTelemetry = value;
+  set enableTelemetry(value) {
+    this.#enableTelemetry = value;
   }
 
-  get enableCAPTelemetry() {
-    return this.#enableCAPTelemetry;
+  get enableTelemetry() {
+    return this.#enableTelemetry;
   }
 
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }
 
+  get _rawEventMap() {
+    return this.#eventMap;
+  }
+
   /**
     @return { Config }
   **/

package/src/index.d.ts

@@ -6,6 +6,7 @@ export declare const EventProcessingStatus: {
   Done: 2;
   Error: 3;
   Exceeded: 4;
+  Suspended: 5;
 };
 
 declare type EventProcessingStatusKeysType = keyof typeof EventProcessingStatus;
@@ -108,6 +109,7 @@ interface EventEntityPublish {
   referenceEntity?: string;
   referenceEntityKey?: string;
   payload?: string;
+  startAfter?: string;
 }
 
 interface EventTriggerProcessing {
@@ -145,6 +147,7 @@ export declare class EventQueueProcessorBase {
   shouldRollbackTransaction(key: string): boolean;
   beforeProcessingEvents(): Promise<void>;
   addEntryToProcessingMap(key: string, queueEntry: EventEntity, payload: Object): void;
+  getTxForEventProcessing(key: string): cds.Transaction;
 
   set logger(value: CdsLogger);
   get logger(): CdsLogger;
@@ -162,15 +165,11 @@ export function publishEvent(
   options?: {
     skipBroadcast?: boolean;
     skipInsertEventsBeforeCommit?: boolean;
+    addTraceContext?: boolean;
   }
 ): Promise<any>;
 
-export function processEventQueue(
-  context: cds.EventContext,
-  eventType: string,
-  eventSubType: string,
-  startTime: Date
-): Promise<any>;
+export function processEventQueue(context: cds.EventContext, eventType: string, eventSubType: string): Promise<any>;
 
 export function triggerEventProcessingRedis(
   tenantId: string,
@@ -256,8 +255,8 @@ declare class Config {
   get redisOptions(): any;
   set insertEventsBeforeCommit(value: any);
   get insertEventsBeforeCommit(): any;
-  set enableCAPTelemetry(value: any);
-  get enableCAPTelemetry(): any;
+  set enableTelemetry(value: any);
+  get enableTelemetry(): any;
   get isMultiTenancy(): boolean;
 }
 

package/src/initialize.js

@@ -40,7 +40,7 @@ const CONFIG_VARS = [
   ["cleanupLocksAndEventsForDev", false],
   ["redisOptions", {}],
   ["insertEventsBeforeCommit", true],
-  ["enableCAPTelemetry", false],
+  ["enableTelemetry", true],
   ["cronTimezone", null],
   ["publishEventBlockList", true],
   ["crashOnRedisUnavailable", false],
@@ -65,7 +65,7 @@ const CONFIG_VARS = [
  * @param {boolean} [options.cleanupLocksAndEventsForDev=false] - Cleanup locks and events for development environments.
  * @param {Object} [options.redisOptions={}] - Configuration options for Redis.
  * @param {boolean} [options.insertEventsBeforeCommit=true] - Insert events into the queue before committing the transaction.
- * @param {boolean} [options.enableCAPTelemetry=false] - Enable telemetry for CAP.
+ * @param {boolean} [options.enableTelemetry=false] - Enable telemetry for CAP.
  * @param {string} [options.cronTimezone=null] - Default timezone for cron jobs.
  * @param {string} [options.publishEventBlockList=true] - If redis is available event blocklist is distributed to all application instances
  * @param {string} [options.crashOnRedisUnavailable=true] - If enabled an error is thrown if the redis connection check is not successful

package/src/periodicEvents.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const cds = require("@sap/cds");
-const cronParser = require("cron-parser");
+const { CronExpressionParser } = require("cron-parser");
 
 const { EventProcessingStatus } = require("./constants");
 const { processChunkedSync } = require("./shared/common");
@@ -117,10 +117,9 @@ const _determineChangedCron = (existingEventsCron) => {
     const config = eventConfig.getEventConfig(event.type, event.subType);
     const eventStartAfter = new Date(event.startAfter);
     const eventCreatedAt = new Date(event.createdAt);
-    const cronExpression = cronParser.parseExpression(config.cron, {
+    const cronExpression = CronExpressionParser.parse(config.cron, {
       currentDate: eventCreatedAt,
-      utc: config.utc,
-      ...(config.useCronTimezone && { tz: eventConfig.cronTimezone }),
+      tz: config.tz,
     });
     return Math.abs(cronExpression.next().getTime() - eventStartAfter.getTime()) > 30 * 1000; // report as changed if diff created than 30 seconds
   });
@@ -135,13 +134,10 @@ const _insertPeriodEvents = async (tx, events, now) => {
     let startTime = now;
     const config = eventConfig.getEventConfig(event.type, event.subType);
     if (config.cron) {
-      startTime = cronParser
-        .parseExpression(config.cron, {
-          currentDate: now,
-          utc: config.utc,
-          ...(config.useCronTimezone && { tz: eventConfig.cronTimezone }),
-        })
-        .next();
+      startTime = CronExpressionParser.parse(config.cron, {
+        currentDate: now,
+        tz: config.tz,
+      }).next();
     }
     base.startAfter = startTime.toISOString();
     return base;

package/src/processEventQueue.js

@@ -9,14 +9,15 @@ const { TransactionMode, EventProcessingStatus } = require("./constants");
 const { limiter } = require("./shared/common");
 
 const { executeInNewTransaction } = require("./shared/cdsHelper");
-const trace = require("./shared/openTelemetry");
+const { trace } = require("./shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/processEventQueue";
 
-const processEventQueue = async (context, eventType, eventSubType, startTime = new Date()) => {
+const processEventQueue = async (context, eventType, eventSubType) => {
   let iterationCounter = 0;
   let shouldContinue = true;
   let baseInstance;
+  let startTime = new Date();
   try {
     let eventTypeInstance;
     const eventConfig = config.getEventConfig(eventType, eventSubType);
@@ -37,10 +38,11 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
     if (!continueProcessing) {
       return;
     }
+    eventConfig.startTime = startTime;
+    eventConfig.lockAcquiredTime = new Date();
     if (baseInstance.isPeriodicEvent) {
       return await processPeriodicEvent(context, baseInstance);
     }
-    eventConfig.startTime = startTime;
     while (shouldContinue) {
       iterationCounter++;
       await executeInNewTransaction(context, `eventQueue-pre-processing-${eventType}##${eventSubType}`, async (tx) => {
@@ -76,28 +78,26 @@ 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;
-          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)
-              )
-            ) {
-              await tx.rollback();
-            }
-          });
+          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)
+            )
+          ) {
+            await tx.rollback();
+          }
         });
       }
       await executeInNewTransaction(context, `eventQueue-persistStatus-${eventType}##${eventSubType}`, async (tx) => {
         await eventTypeInstance.persistEventStatus(tx);
       });
-      shouldContinue = reevaluateShouldContinue(eventTypeInstance, iterationCounter, startTime);
+      shouldContinue = reevaluateShouldContinue(eventTypeInstance, iterationCounter, eventConfig.startTime);
     }
   } catch (err) {
     cds.log(COMPONENT_NAME).error("Processing event queue failed with unexpected error.", err, {
@@ -317,18 +317,30 @@ const _checkEventIsBlocked = async (baseInstance) => {
 };
 
 const _processEvent = async (eventTypeInstance, processContext, key, queueEntries, payload) => {
-  try {
-    const eventOutdated = await eventTypeInstance.isOutdatedAndKeepAlive(queueEntries);
-    if (eventOutdated) {
-      // NOTE: return empty status map to comply with the interface
-      return {};
-    }
-    eventTypeInstance.setTxForEventProcessing(key, cds.tx(processContext));
-    const statusTuple = await eventTypeInstance.processEvent(processContext, key, queueEntries, payload);
-    return eventTypeInstance.setEventStatus(queueEntries, statusTuple);
-  } catch (err) {
-    return eventTypeInstance.handleErrorDuringProcessing(err, queueEntries);
+  let traceContext;
+  if (queueEntries.length === 1 && eventTypeInstance.inheritTraceContext) {
+    traceContext = queueEntries[0].context?.traceContext;
   }
+
+  return await trace(
+    eventTypeInstance.baseContext,
+    `process-event-${eventTypeInstance.eventType}-${eventTypeInstance.eventSubType}`,
+    async () => {
+      try {
+        const eventOutdated = await eventTypeInstance.isOutdatedAndKeepAlive(queueEntries);
+        if (eventOutdated) {
+          // NOTE: return empty status map to comply with the interface
+          return {};
+        }
+        eventTypeInstance.setTxForEventProcessing(key, cds.tx(processContext));
+        const statusTuple = await eventTypeInstance.processEvent(processContext, key, queueEntries, payload);
+        return eventTypeInstance.setEventStatus(queueEntries, statusTuple);
+      } catch (err) {
+        return eventTypeInstance.handleErrorDuringProcessing(err, queueEntries);
+      }
+    },
+    { traceContext }
+  );
 };
 
 const resilientRequire = async (eventConfig) => {

package/src/publishEvent.js

@@ -3,6 +3,7 @@
 const config = require("./config");
 const common = require("./shared/common");
 const EventQueueError = require("./EventQueueError");
+const openTelemetry = require("./shared/openTelemetry");
 
 /**
  * Asynchronously publishes a series of events to the event queue.
@@ -29,7 +30,11 @@ const EventQueueError = require("./EventQueueError");
  * @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.
  */
-const publishEvent = async (tx, events, { skipBroadcast = false, skipInsertEventsBeforeCommit = false } = {}) => {
+const publishEvent = async (
+  tx,
+  events,
+  { skipBroadcast = false, skipInsertEventsBeforeCommit = false, addTraceContext = true } = {}
+) => {
   if (!config.initialized) {
     throw EventQueueError.notInitialized();
   }
@@ -51,6 +56,10 @@ const publishEvent = async (tx, events, { skipBroadcast = false, skipInsertEvent
     if (typeof event.payload !== "string") {
       event.payload = JSON.stringify(event.payload);
     }
+
+    if (addTraceContext) {
+      event.context = JSON.stringify({ traceContext: openTelemetry.getCurrentTraceContext() });
+    }
   }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);

package/src/redis/redisPub.js

@@ -9,7 +9,7 @@ const distributedLock = require("../shared/distributedLock");
 const config = require("../config");
 const common = require("../shared/common");
 const { runEventCombinationForTenant } = require("../runner/runnerHelper");
-const trace = require("../shared/openTelemetry");
+const { trace } = require("../shared/openTelemetry");
 const { TenantIdCheckTypes } = require("../constants");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";

package/src/runner/runner.js

@@ -15,7 +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 { trace } = require("../shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
@@ -77,20 +77,24 @@ const _multiTenancyRedis = async () => {
   try {
     logger.info("executing event queue run for multi instance and tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
-    await _checkPeriodicEventUpdate(tenantIds);
-    return await _executeEventsAllTenantsRedis(tenantIds);
+    const shouldContinue = await _checkPeriodicEventUpdate(tenantIds);
+    shouldContinue && (await _executeEventsAllTenantsRedis(tenantIds));
   } catch (err) {
     logger.info("executing event queue run for multi instance and tenant failed", err);
   }
 };
 
+// NOTE: _checkPeriodicEventUpdate the function must return truthy if _executeEventsAllTenantsRedis should continue
+//       processing open events. The idea is: if _multiTenancyPeriodicEvents is executed after the deployment we want
+//       to wait for all instances that periodic events are up-to-date and the updating of periodic events does not
+//       interfere with the processing of events
 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;
+    return true;
   }
   const hash = common.hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
@@ -102,9 +106,12 @@ const _checkPeriodicEventUpdate = async (tenantIds) => {
   if (tenantIdHash && tenantIdHash !== hash) {
     tenantIdHash = hash;
     cds.log(COMPONENT_NAME).info("tenant id hash changed, triggering updating periodic events!");
-    return await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
+    await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
       cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events!", err);
     });
+    return true;
+  } else {
+    return true;
   }
 };
 
@@ -461,7 +468,8 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
         }
 
         tenantIds = tenantIds ?? (await cdsHelper.getAllTenantIds());
-        return await _executePeriodicEventsAllTenants(tenantIds);
+        await _executePeriodicEventsAllTenants(tenantIds);
+        return true;
       },
       { newRootSpan: true }
     );

package/src/runner/runnerHelper.js

@@ -8,7 +8,7 @@ const { processEventQueue } = require("../processEventQueue");
 const eventQueueConfig = require("../config");
 const WorkerQueue = require("../shared/WorkerQueue");
 const distributedLock = require("../shared/distributedLock");
-const trace = require("../shared/openTelemetry");
+const { trace } = require("../shared/openTelemetry");
 
 const COMPONENT_NAME = "/eventQueue/runnerHelper";
 

package/src/shared/SetIntervalDriftSafe.js

@@ -17,6 +17,11 @@ class SetIntervalDriftSafe {
     this.#logger = cds.log(COMPONENT);
   }
 
+  start(fn) {
+    this.#shouldRun = true;
+    this.run(fn);
+  }
+
   run(fn) {
     if (!this.#shouldRun) {
       return;

package/src/shared/openTelemetry.js

@@ -1,32 +1,56 @@
 "use strict";
 
+const _resilientRequire = (module) => {
+  try {
+    return require(module);
+  } catch {
+    // ignore
+  }
+};
+
 const cds = require("@sap/cds");
-let otel;
-try {
-  otel = require("@opentelemetry/api");
-} catch {
-  // ignore
-}
+const otel = _resilientRequire("@opentelemetry/api");
 
 const config = require("../config");
 
 const COMPONENT_NAME = "/shared/openTelemetry";
 
-const trace = async (context, label, fn, { attributes = {}, newRootSpan = false } = {}) => {
-  const tracerProvider = otel?.trace.getTracerProvider();
-  // Check if a real provider is registered
-  if (!config.enableCAPTelemetry || !tracerProvider || tracerProvider === otel.trace.NOOP_TRACER_PROVIDER) {
+const trace = async (context, label, fn, { attributes = {}, newRootSpan = false, traceContext } = {}) => {
+  if (!config.enableTelemetry || !otel) {
     return fn();
   }
 
-  const tracer = otel.trace.getTracer("eventqueue");
-  const span = tracer.startSpan(`eventqueue-${label}`, {
-    kind: otel.SpanKind.INTERNAL,
-    root: newRootSpan,
-  });
+  const tracerProvider = otel.trace.getTracerProvider();
+  if ((!tracerProvider || tracerProvider === otel.trace.NOOP_TRACER_PROVIDER) && !process.env.DT_NODE_PRELOAD_OPTIONS) {
+    return fn();
+  }
+
+  const tracer = otel.trace.getTracer("@cap-js-community/event-queue");
+  const extractedContext = traceContext
+    ? otel.propagation.extract(otel.context.active(), traceContext)
+    : otel.context.active();
+  const span = tracer.startSpan(
+    `eventqueue-${label}`,
+    {
+      kind: otel.SpanKind.INTERNAL,
+      root: newRootSpan,
+    },
+    extractedContext
+  );
   _setAttributes(context, span, attributes);
-  const ctxWithSpan = otel.trace.setSpan(otel.context.active(), span);
+  const ctxWithSpan = otel.trace.setSpan(extractedContext, span);
+
+  return await _startOtelTrace(ctxWithSpan, traceContext, span, fn);
+};
+
+const _startOtelTrace = async (ctxWithSpan, traceContext, span, fn) => {
   return otel.context.with(ctxWithSpan, async () => {
+    if (traceContext) {
+      cds.log("/eventQueue/telemetry").info("Linked span:", span.spanContext());
+      const carrier = {};
+      otel.propagation.inject(ctxWithSpan, carrier);
+      cds.log("/eventQueue/telemetry").info("Extracted trace context by inject", carrier);
+    }
     const onSuccess = (res) => {
       span.setStatus({ code: otel.SpanStatusCode.OK });
       return res;
@@ -72,4 +96,13 @@ const _setAttributes = (context, span, attributes) => {
   }
 };
 
-module.exports = trace;
+const getCurrentTraceContext = () => {
+  if (!otel) {
+    return null;
+  }
+  const carrier = {};
+  otel.propagation.inject(otel.context.active(), carrier);
+  return carrier;
+};
+
+module.exports = { trace, getCurrentTraceContext };