@cap-js-community/event-queue 1.3.6 → 1.4.1

package/cds-plugin.js

@@ -6,5 +6,5 @@ const eventQueue = require("./src");
 const COMPONENT_NAME = "/eventQueue/plugin";
 
 if (!cds.build.register && cds.env.eventQueue) {
-  eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
+  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.3.6",
+  "version": "1.4.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",
   "files": [
@@ -42,12 +42,13 @@
     "node": ">=18"
   },
   "dependencies": {
-    "redis": "4.6.13",
-    "verror": "1.10.1",
-    "yaml": "2.4.1"
+    "@sap/xssec": "^3.6.1",
+    "redis": "^4.6.13",
+    "verror": "^1.10.1",
+    "yaml": "^2.4.1"
   },
   "devDependencies": {
-    "@cap-js/hana": "^0.0.6",
+    "@cap-js/hana": "^0.1.0",
     "@cap-js/sqlite": "^1.5.0",
     "@sap/cds": "^7.7.0",
     "@sap/cds-dk": "^7.5.1",

package/src/EventQueueProcessorBase.js

@@ -10,7 +10,7 @@ const { arrayToFlatMap } = require("./shared/common");
 const eventScheduler = require("./shared/eventScheduler");
 const eventConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
-const { broadcastEvent } = require("./redisPubSub");
+const { broadcastEvent } = require("./redis/redisPub");
 
 const IMPLEMENT_ERROR_MESSAGE = "needs to be reimplemented";
 const COMPONENT_NAME = "/eventQueue/EventQueueProcessorBase";
@@ -23,8 +23,6 @@ const TRIES_FOR_EXCEEDED_EVENTS = 3;
 const EVENT_START_AFTER_HEADROOM = 3 * 1000;
 const ETAG_CHECK_AFTER_MIN = 10;
 
-let serviceBindingCache = null;
-
 class EventQueueProcessorBase {
   #eventsWithExceededTries = [];
   #exceededTriesExceeded = [];
@@ -72,8 +70,6 @@ class EventQueueProcessorBase {
     this.__txMap = {};
     this.__txRollback = {};
     this.__queueEntries = [];
-
-    this.#checkGlobalContextToLocalContext();
   }
 
   /**
@@ -537,10 +533,7 @@ class EventQueueProcessorBase {
   async getQueueEntriesAndSetToInProgress() {
     let result = [];
     const refDateStartAfter = new Date(Date.now() + this.#config.runInterval * 1.2);
-    this.#checkGlobalContextToLocalContext();
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
-      this.#checkGlobalContextToLocalContext();
-      await this.checkTxConsistency(tx);
       const entries = await tx.run(
         SELECT.from(this.#config.tableNameEventQueue)
           .forUpdate({ wait: this.#config.forUpdateTimeout })
@@ -667,57 +660,6 @@ class EventQueueProcessorBase {
     return result;
   }
 
-  async checkTxConsistency(tx) {
-    if (!this.#config.enableTxConsistencyCheck) {
-      return;
-    }
-
-    const errorHandler = (err) =>
-      this.logger.error("tx consistency check failed!", err, {
-        type: this.eventType,
-        subType: this.eventSubType,
-        txTenant: tx.context.tenant,
-        globalCdsTenant: cds.context.tenant,
-      });
-    let txSchema, serviceManagerSchema;
-    try {
-      const schemaPromise = tx.run("SELECT CURRENT_SCHEMA FROM DUMMY");
-      const [schema, serviceManagerBindings] = await Promise.allSettled([schemaPromise, this.#getServiceBindings()]);
-      if (schema.reason) {
-        errorHandler(schema.reason);
-        return;
-      }
-      if (serviceManagerBindings.reason) {
-        errorHandler(serviceManagerBindings.reason);
-        return;
-      }
-
-      txSchema = schema.value[0].CURRENT_SCHEMA;
-      serviceManagerSchema = serviceManagerBindings.value.find((t) => t.labels.tenant_id[0] === tx.context.tenant)
-        .credentials.schema;
-    } catch (err) {
-      errorHandler(err);
-    }
-    if (serviceManagerSchema && txSchema !== serviceManagerSchema) {
-      const err = EventQueueError.dbClientSchemaMismatch(tx.context.tenant, txSchema, serviceManagerSchema);
-      errorHandler(err);
-      throw err;
-    }
-  }
-
-  async #getServiceBindings() {
-    if (!(serviceBindingCache && serviceBindingCache.expireTs >= Date.now())) {
-      const mtxServiceManager = require("@sap/cds-mtxs/srv/plugins/hana/srv-mgr");
-      serviceBindingCache = {
-        expireTs: Date.now() + 10 * 60 * 1000,
-        value: mtxServiceManager.getAll().catch(() => {
-          serviceBindingCache = null;
-        }),
-      };
-    }
-    return await serviceBindingCache.value;
-  }
-
   async #selectLastSuccessfulPeriodicTimestamp() {
     const entry = await SELECT.one
       .from(this.#config.tableNameEventQueue)
@@ -730,48 +672,6 @@ class EventQueueProcessorBase {
     return entry.lastAttemptsTs;
   }
 
-  #checkGlobalContextToLocalContext() {
-    if (!this.#config.enableTxConsistencyCheck) {
-      return;
-    }
-    if (this.__context.tenant !== cds.context.tenant) {
-      throw EventQueueError.globalCdsContextNotMatchingLocal(
-        JSON.stringify(
-          {
-            correlationId: cds.context.id,
-            tenantId: cds.context.tenant,
-            timestamp: cds.context.timestamp,
-            base: JSON.stringify(
-              {
-                correlationId: cds.context.context?.id,
-                tenantId: cds.context.context?.tenant,
-                timestamp: cds.context.context?.timestamp,
-              },
-              null,
-              2
-            ),
-          },
-          null,
-          2
-        ),
-        JSON.stringify(
-          {
-            correlationId: this.__context.id,
-            tenantId: this.__context.tenant,
-            timestamp: this.__context.timestamp,
-            base: JSON.stringify({
-              correlationId: this.__context.context?.id,
-              tenantId: this.__context.context?.tenant,
-              timestamp: this.__context.context?.timestamp,
-            }),
-          },
-          null,
-          2
-        )
-      );
-    }
-  }
-
   #handleDelayedEvents(delayedEvents) {
     for (const delayedEvent of delayedEvents) {
       this.#eventSchedulerInstance.scheduleEvent(
@@ -1113,7 +1013,7 @@ class EventQueueProcessorBase {
 
   broadCastEvent() {
     setTimeout(() => {
-      broadcastEvent(this.__baseContext.tenant, this.#eventType, this.#eventSubType).catch((err) => {
+      broadcastEvent(this.__baseContext.tenant, { type: this.#eventType, subType: this.#eventSubType }).catch((err) => {
         this.logger.error("could not execute scheduled event", err, {
           tenantId: this.__baseContext.tenant,
           type: this.#eventType,

package/src/config.js

@@ -34,6 +34,11 @@ const BASE_PERIODIC_EVENTS = [
   },
 ];
 
+const BASE_TABLES = {
+  EVENT: "sap.eventqueue.Event",
+  LOCK: "sap.eventqueue.Lock",
+};
+
 class Config {
   #logger;
   #config;
@@ -59,8 +64,8 @@ class Config {
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
   #userId;
-  #enableTxConsistencyCheck;
   #cleanupLocksAndEventsForDev;
+  #redisOptions;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -105,7 +110,7 @@ class Config {
 
   attachConfigChangeHandler() {
     this.#attachBlockListChangeHandler();
-    redis.subscribeRedisChannel(REDIS_CONFIG_CHANNEL, (messageData) => {
+    redis.subscribeRedisChannel(this.#redisOptions, REDIS_CONFIG_CHANNEL, (messageData) => {
       try {
         const { key, value } = JSON.parse(messageData);
         if (this[key] !== value) {
@@ -125,13 +130,13 @@ class Config {
       this.#logger.info("redis not connected, config change won't be published", { key, value });
       return;
     }
-    redis.publishMessage(REDIS_CONFIG_CHANNEL, JSON.stringify({ key, value })).catch((error) => {
+    redis.publishMessage(this.#redisOptions, REDIS_CONFIG_CHANNEL, JSON.stringify({ key, value })).catch((error) => {
       this.#logger.error(`publishing config change failed key: ${key}, value: ${value}`, error);
     });
   }
 
   #attachBlockListChangeHandler() {
-    redis.subscribeRedisChannel(REDIS_CONFIG_BLOCKLIST_CHANNEL, (messageData) => {
+    redis.subscribeRedisChannel(this.#redisOptions, REDIS_CONFIG_BLOCKLIST_CHANNEL, (messageData) => {
       try {
         const { command, key, tenant } = JSON.parse(messageData);
         if (command === COMMAND_BLOCK) {
@@ -160,7 +165,11 @@ class Config {
     }
 
     redis
-      .publishMessage(REDIS_CONFIG_BLOCKLIST_CHANNEL, JSON.stringify({ command: COMMAND_BLOCK, key, tenant }))
+      .publishMessage(
+        this.#redisOptions,
+        REDIS_CONFIG_BLOCKLIST_CHANNEL,
+        JSON.stringify({ command: COMMAND_BLOCK, key, tenant })
+      )
       .catch((error) => {
         this.#logger.error(`publishing config block failed key: ${key}`, error);
       });
@@ -189,7 +198,11 @@ class Config {
     }
 
     redis
-      .publishMessage(REDIS_CONFIG_BLOCKLIST_CHANNEL, JSON.stringify({ command: COMMAND_UNBLOCK, key, tenant }))
+      .publishMessage(
+        this.#redisOptions,
+        REDIS_CONFIG_BLOCKLIST_CHANNEL,
+        JSON.stringify({ command: COMMAND_UNBLOCK, key, tenant })
+      )
       .catch((error) => {
         this.#logger.error(`publishing config block failed key: ${key}`, error);
       });
@@ -386,19 +399,11 @@ class Config {
   }
 
   get tableNameEventQueue() {
-    return this.#tableNameEventQueue;
-  }
-
-  set tableNameEventQueue(value) {
-    this.#tableNameEventQueue = value;
+    return BASE_TABLES.EVENT;
   }
 
   get tableNameEventLock() {
-    return this.#tableNameEventLock;
-  }
-
-  set tableNameEventLock(value) {
-    this.#tableNameEventLock = value;
+    return BASE_TABLES.LOCK;
   }
 
   set configFilePath(value) {
@@ -473,14 +478,6 @@ class Config {
     return this.#userId;
   }
 
-  set enableTxConsistencyCheck(value) {
-    this.#enableTxConsistencyCheck = value;
-  }
-
-  get enableTxConsistencyCheck() {
-    return this.#enableTxConsistencyCheck;
-  }
-
   set cleanupLocksAndEventsForDev(value) {
     this.#cleanupLocksAndEventsForDev = value;
   }
@@ -489,6 +486,14 @@ class Config {
     return this.#cleanupLocksAndEventsForDev;
   }
 
+  set redisOptions(value) {
+    this.#redisOptions = value;
+  }
+
+  get redisOptions() {
+    return this.#redisOptions;
+  }
+
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }

package/src/dbHandler.js

@@ -2,7 +2,7 @@
 
 const cds = require("@sap/cds");
 
-const { broadcastEvent } = require("./redisPubSub");
+const { broadcastEvent } = require("./redis/redisPub");
 const config = require("./config");
 
 const COMPONENT_NAME = "/eventQueue/dbHandler";
@@ -31,14 +31,17 @@ const registerEventQueueDbHandler = (dbService) => {
 
     eventCombinations.length &&
       req.on("succeeded", () => {
-        for (const eventCombination of eventCombinations) {
-          broadcastEvent(req.tenant, ...eventCombination.split("##")).catch((err) => {
-            cds.log(COMPONENT_NAME).error("db handler failure during broadcasting event", err, {
-              tenant: req.tenant,
-              eventCombination,
-            });
+        const events = eventCombinations.map((eventCombination) => {
+          const [type, subType] = eventCombination.split("##");
+          return { type, subType };
+        });
+
+        broadcastEvent(req.tenant, events).catch((err) => {
+          cds.log(COMPONENT_NAME).error("db handler failure during broadcasting event", err, {
+            tenant: req.tenant,
+            events,
           });
-        }
+        });
       });
   });
 };

package/src/initialize.js

@@ -7,11 +7,10 @@ const cds = require("@sap/cds");
 const yaml = require("yaml");
 const VError = require("verror");
 
-const EventQueueError = require("./EventQueueError");
-const runner = require("./runner");
+const runner = require("./runner/runner");
 const dbHandler = require("./dbHandler");
 const config = require("./config");
-const { initEventQueueRedisSubscribe, closeSubscribeClient } = require("./redisPubSub");
+const { initEventQueueRedisSubscribe, closeSubscribeClient } = require("./redis/redisSub");
 const redis = require("./shared/redis");
 const eventQueueAsOutbox = require("./outbox/eventQueueAsOutbox");
 const { getAllTenantIds } = require("./shared/cdsHelper");
@@ -21,26 +20,20 @@ const readFileAsync = promisify(fs.readFile);
 
 const VERROR_CLUSTER_NAME = "EventQueueInitialization";
 const COMPONENT = "eventQueue/initialize";
-const BASE_TABLES = {
-  EVENT: "sap.eventqueue.Event",
-  LOCK: "sap.eventqueue.Lock",
-};
+
 const CONFIG_VARS = [
   ["configFilePath", null],
   ["registerAsEventProcessor", true],
   ["processEventsAfterPublish", true],
   ["isEventQueueActive", true],
   ["runInterval", 25 * 60 * 1000],
-  ["tableNameEventQueue", BASE_TABLES.EVENT],
-  ["tableNameEventLock", BASE_TABLES.LOCK],
   ["disableRedis", true],
-  ["skipCsnCheck", false],
   ["updatePeriodicEvents", true],
   ["thresholdLoggingEventProcessing", 50],
   ["useAsCAPOutbox", false],
   ["userId", null],
-  ["enableTxConsistencyCheck", false],
   ["cleanupLocksAndEventsForDev", false],
+  ["redisOptions", {}],
 ];
 
 const initialize = async ({
@@ -49,16 +42,13 @@ const initialize = async ({
   processEventsAfterPublish,
   isEventQueueActive,
   runInterval,
-  tableNameEventQueue,
-  tableNameEventLock,
   disableRedis,
-  skipCsnCheck,
   updatePeriodicEvents,
   thresholdLoggingEventProcessing,
   useAsCAPOutbox,
   userId,
-  enableTxConsistencyCheck,
   cleanupLocksAndEventsForDev,
+  redisOptions,
 } = {}) => {
   if (config.initialized) {
     return;
@@ -71,16 +61,13 @@ const initialize = async ({
     processEventsAfterPublish,
     isEventQueueActive,
     runInterval,
-    tableNameEventQueue,
-    tableNameEventLock,
     disableRedis,
-    skipCsnCheck,
     updatePeriodicEvents,
     thresholdLoggingEventProcessing,
     useAsCAPOutbox,
     userId,
-    enableTxConsistencyCheck,
-    cleanupLocksAndEventsForDev
+    cleanupLocksAndEventsForDev,
+    redisOptions
   );
 
   const logger = cds.log(COMPONENT);
@@ -95,12 +82,10 @@ const initialize = async ({
     }
   });
   if (redisEnabled) {
-    config.redisEnabled = await redis.connectionCheck();
+    config.redisEnabled = await redis.connectionCheck(config.redisOptions);
   }
   config.fileContent = await readConfigFromFile(config.configFilePath);
 
-  !config.skipCsnCheck && (await csnCheck());
-
   monkeyPatchCAPOutbox();
   registerCdsShutdown();
   logger.info("event queue initialized", {
@@ -172,50 +157,6 @@ const monkeyPatchCAPOutbox = () => {
   }
 };
 
-const csnCheck = async () => {
-  cds.on("loaded", async (csn) => {
-    if (csn.namespace === "cds.xt") {
-      return;
-    }
-    const eventCsn = csn.definitions[config.tableNameEventQueue];
-    if (!eventCsn) {
-      throw EventQueueError.missingTableInCsn(config.tableNameEventQueue);
-    }
-
-    const lockCsn = csn.definitions[config.tableNameEventLock];
-    if (!lockCsn) {
-      throw EventQueueError.missingTableInCsn(config.tableNameEventLock);
-    }
-
-    if (config.tableNameEventQueue === BASE_TABLES.EVENT && config.tableNameEventLock === BASE_TABLES.LOCK) {
-      return; // no need to check base tables
-    }
-
-    const baseEvent = csn.definitions["sap.eventqueue.Event"];
-    const baseLock = csn.definitions["sap.eventqueue.Lock"];
-
-    checkCustomTable(baseEvent, eventCsn);
-    checkCustomTable(baseLock, lockCsn);
-  });
-};
-
-const checkCustomTable = (baseCsn, customCsn) => {
-  for (const columnName in baseCsn.elements) {
-    if (!customCsn.elements[columnName]) {
-      throw EventQueueError.missingElementInTable(customCsn.name, columnName);
-    }
-
-    if (
-      customCsn.elements[columnName].type !== "cds.Association" &&
-      customCsn.elements[columnName].type !== baseCsn.elements[columnName].type &&
-      columnName === "status" &&
-      customCsn.elements[columnName].type !== "cds.Integer"
-    ) {
-      throw EventQueueError.typeMismatchInTable(customCsn.name, columnName);
-    }
-  }
-};
-
 const mixConfigVarsWithEnv = (...args) => {
   CONFIG_VARS.forEach(([configName, defaultValue], index) => {
     const configValue = args[index];

package/src/processEventQueue.js

@@ -96,9 +96,6 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
     }
   } catch (err) {
     cds.log(COMPONENT_NAME).error("Processing event queue failed with unexpected error.", err, {
-      tenantId: context?.tenant,
-      tenantIdBase: baseInstance?.context?.tenant,
-      globalTenantId: cds.context?.tenant,
       eventType,
       eventSubType,
     });
@@ -188,9 +185,6 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
     cds.log(COMPONENT_NAME).error("Processing periodic events failed with unexpected error.", err, {
       eventType: eventTypeInstance?.eventType,
       eventSubType: eventTypeInstance?.eventSubType,
-      tenantId: context?.tenant,
-      tenantIdBase: eventTypeInstance?.context?.tenant,
-      globalTenantId: cds.context?.tenant,
     });
   } finally {
     await eventTypeInstance?.handleReleaseLock();

package/src/redis/redisPub.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { promisify } = require("util");
+
+const cds = require("@sap/cds");
+
+const redis = require("../shared/redis");
+const { checkLockExistsAndReturnValue } = require("../shared/distributedLock");
+const config = require("../config");
+const common = require("../shared/common");
+const { runEventCombinationForTenant } = require("../runner/runnerHelper");
+
+const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
+const COMPONENT_NAME = "/eventQueue/redisPub";
+const TRIES_FOR_PUBLISH_PERIODIC_EVENT = 10;
+const SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT = 30 * 1000;
+
+const wait = promisify(setTimeout);
+
+const broadcastEvent = async (tenantId, events) => {
+  const logger = cds.log(COMPONENT_NAME);
+  events = Array.isArray(events) ? events : [events];
+  try {
+    if (!config.isEventQueueActive) {
+      cds.log(COMPONENT_NAME).info("Skipping processing because runner is deactivated!", {});
+      return;
+    }
+    if (!config.redisEnabled) {
+      if (config.registerAsEventProcessor) {
+        let context = {};
+        if (tenantId) {
+          const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+          context = {
+            tenant: tenantId,
+            user,
+          };
+        }
+
+        return await cds.tx(context, async ({ context }) => {
+          for (const { type, subType } of events) {
+            await runEventCombinationForTenant(context, type, subType);
+          }
+        });
+      }
+      return;
+    }
+    for (const { type, subType } of events) {
+      const eventConfig = config.getEventConfig(type, subType);
+      for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
+        const result = await checkLockExistsAndReturnValue(
+          new cds.EventContext({ tenant: tenantId }),
+          [type, subType].join("##")
+        );
+        if (result) {
+          logger.debug("skip publish redis event as no lock is available", {
+            type,
+            subType,
+            index: i,
+            isPeriodic: eventConfig.isPeriodic,
+            waitInterval: SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT,
+          });
+          if (!eventConfig.isPeriodic) {
+            break;
+          }
+          await wait(SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT);
+          continue;
+        }
+        logger.debug("publishing redis event", {
+          tenantId,
+          type,
+          subType,
+        });
+        await redis.publishMessage(
+          config.redisOptions,
+          EVENT_MESSAGE_CHANNEL,
+          JSON.stringify({ tenantId, type, subType })
+        );
+        break;
+      }
+    }
+  } catch (err) {
+    logger.error("publish events failed!", err, {
+      tenantId,
+    });
+  }
+};
+
+module.exports = {
+  broadcastEvent,
+};

package/src/redis/redisSub.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const redis = require("../shared/redis");
+const config = require("../config");
+const runnerHelper = require("../runner/runnerHelper");
+const common = require("../shared/common");
+
+const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
+const COMPONENT_NAME = "/eventQueue/redisSub";
+let subscriberClientPromise;
+
+const initEventQueueRedisSubscribe = () => {
+  if (subscriberClientPromise || !config.redisEnabled) {
+    return;
+  }
+  redis.subscribeRedisChannel(config.redisOptions, EVENT_MESSAGE_CHANNEL, _messageHandlerProcessEvents);
+};
+
+const _messageHandlerProcessEvents = async (messageData) => {
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    const { tenantId, type, subType } = JSON.parse(messageData);
+    logger.debug("received redis event", {
+      tenantId,
+      type,
+      subType,
+    });
+    if (!config.isEventQueueActive) {
+      cds.log(COMPONENT_NAME).info("Skipping processing because runner is deactivated!", {
+        type,
+        subType,
+      });
+      return;
+    }
+
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    const tenantContext = {
+      tenant: tenantId,
+      user,
+    };
+
+    if (!config.getEventConfig(type, subType)) {
+      if (config.isCapOutboxEvent(type)) {
+        try {
+          const service = await cds.connect.to(subType);
+          cds.outboxed(service);
+        } catch (err) {
+          logger.error("could not connect to outboxed service", err, {
+            type,
+            subType,
+          });
+          return;
+        }
+      } else {
+        logger.error("cannot find configuration for published event. Event won't be processed", {
+          type,
+          subType,
+        });
+        return;
+      }
+    }
+
+    return await cds.tx(tenantContext, async ({ context }) => {
+      return await runnerHelper.runEventCombinationForTenant(context, type, subType);
+    });
+  } catch (err) {
+    logger.error("could not parse event information", {
+      messageData,
+    });
+  }
+};
+
+const closeSubscribeClient = async () => {
+  try {
+    const client = await subscriberClientPromise;
+    if (client?.quit) {
+      await client.quit();
+    }
+  } catch (err) {
+    // ignore errors during shutdown
+  }
+};
+
+module.exports = {
+  initEventQueueRedisSubscribe,
+  closeSubscribeClient,
+  __: {
+    _messageHandlerProcessEvents,
+  },
+};