@cap-js-community/event-queue 1.6.2 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "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,9 +63,6 @@
     "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

@@ -384,38 +384,46 @@ 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 } = {}) {
-    return await trace(this.baseContext, "persist-event-status", async () => {
-      this.logger.debug("entering persistEventStatus", {
+    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: [],
+      }
+    );
+    if (![success, failed, exceeded, invalidAttempts].some((statusArray) => statusArray.length)) {
+      this.logger.debug("exiting 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;
+    }
+
+    return await trace(this.baseContext, "persist-event-status", async () => {
       this.logger.debug("persistEventStatus for entries", {
         eventType: this.#eventType,
         eventSubType: this.#eventSubType,
@@ -455,10 +463,6 @@ class EventQueueProcessorBase {
             .where("ID IN", eventIds)
         );
       }
-      this.logger.debug("exiting persistEventStatus", {
-        eventType: this.#eventType,
-        eventSubType: this.#eventSubType,
-      });
     });
   }
 
@@ -916,7 +920,7 @@ class EventQueueProcessorBase {
       return;
     }
     try {
-      await trace(this.baseContext, "persist-release-lock", async () => {
+      await trace(this.baseContext, "release-lock", async () => {
         await distributedLock.releaseLock(this.context, [this.#eventType, this.#eventSubType].join("##"));
       });
     } catch (err) {
@@ -1156,6 +1160,10 @@ class EventQueueProcessorBase {
   get isPeriodicEvent() {
     return this.#eventConfig.isPeriodic;
   }
+
+  get eventConfig() {
+    return this.#eventConfig;
+  }
 }
 
 module.exports = EventQueueProcessorBase;

package/src/config.js

@@ -282,6 +282,7 @@ class Config {
       checkForNextChunk: config.checkForNextChunk,
       deleteFinishedEventsAfterDays: config.deleteFinishedEventsAfterDays,
       appNames: config.appNames,
+      useEventQueueUser: config.useEventQueueUser,
       internalEvent: true,
     };
     eventConfig._appNameMap = eventConfig.appNames

package/src/index.d.ts

@@ -63,6 +63,24 @@ type EventConfigType = {
   isPeriodic: boolean;
 };
 
+export type EventConfig = {
+  type: string;
+  subType: string;
+  load: number;
+  impl: string;
+  selectMaxChunkSize: number | undefined;
+  parallelEventProcessing: boolean;
+  retryAttempts: number | undefined;
+  transactionMode: string | undefined;
+  processAfterCommit: boolean | undefined;
+  eventOutdatedCheck: boolean | undefined;
+  checkForNextChunk: boolean | undefined;
+  deleteFinishedEventsAfterDays: number | undefined;
+  appNames: string[] | undefined;
+  useEventQueueUser: boolean | undefined;
+  internalEvent: true;
+};
+
 // Define Status Type
 type Status = 0 | 1 | 2 | 3 | 4;
 
@@ -126,6 +144,7 @@ export declare class EventQueueProcessorBase {
   get isPeriodicEvent(): boolean;
   get eventType(): String;
   get eventSubType(): String;
+  get eventConfig(): EventConfig;
 }
 
 export function publishEvent(

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -5,6 +5,7 @@ const cds = require("@sap/cds");
 const EventQueueBaseClass = require("../EventQueueProcessorBase");
 const { EventProcessingStatus } = require("../constants");
 const common = require("../shared/common");
+const config = require("../config");
 
 const COMPONENT_NAME = "/eventQueue/outbox/generic";
 
@@ -18,7 +19,8 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     let status = EventProcessingStatus.Done;
     try {
       const service = await cds.connect.to(this.eventSubType);
-      const userId = payload.contextUser;
+      const { useEventQueueUser } = this.eventConfig;
+      const userId = useEventQueueUser ? config.userId : payload.contextUser;
       const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
       const invocationFn = payload._fromSend ? "send" : "emit";
       delete msg._fromSend;

package/src/shared/openTelemetry.js

@@ -10,6 +10,8 @@ try {
 
 const config = require("../config");
 
+const COMPONENT_NAME = "/shared/openTelemetry";
+
 const trace = async (context, label, fn, { attributes = {}, newRootSpan = false } = {}) => {
   if (!config.enableCAPTelemetry || !otel || !cds._telemetry?.tracer) {
     return fn();
@@ -34,8 +36,14 @@ const trace = async (context, label, fn, { attributes = {}, newRootSpan = false
       throw e;
     };
     const onDone = () => {
-      if (span.status.code !== otel.SpanStatusCode.UNSET && !span.ended) {
-        span.end();
+      try {
+        if (span.status?.code !== otel.SpanStatusCode.UNSET && !span.ended) {
+          span.end?.();
+        }
+      } catch (err) {
+        cds.log(COMPONENT_NAME).error("error in tracing", err, {
+          span,
+        });
       }
     };