@jetit/publisher 3.3.3 → 4.0.0

package/README.md

@@ -198,4 +198,6 @@ streams.listen('my-event').subscribe(event => {
 
 7. Event-driven workflows: You can use the publisher to create event-driven workflows, where each step in the workflow is triggered by the completion of a previous step. This can be useful for orchestrating complex, multi-step processes.
 
-8. Message broadcasting: The publisher can be used to broadcast messages to multiple consumers or subscribers, allowing for efficient and scalable communication in applications with many components or services.
+8. Message broadcasting: The publisher can be used to broadcast messages to multiple consumers or subscribers, allowing for efficient and scalable communication in applications with many components or services.
+
+9. Multicast Publishing: This is the existing PUB/SUB implementation but with the event data being stored into streams for additional processing

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@jetit/publisher",
-  "version": "3.3.3",
+  "version": "4.0.0",
   "type": "commonjs",
   "dependencies": {
-    "@jetit/id": "0.0.11",
+    "@jetit/id": "^0.0.12",
     "ioredis": "^5.3.0",
-    "rxjs": "^7.8.0"
-  },
-  "peerDependencies": {
+    "rxjs": "^7.8.0",
     "tslib": "1.14.1"
   },
   "main": "./src/index.js"

package/src/lib/redis/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const PUBLISHER_LOGGER: {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export declare const PERFORMANCE_LOGGER: {
+    log: (...args: unknown[]) => void;
+};

package/src/lib/redis/logger.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERFORMANCE_LOGGER = exports.PUBLISHER_LOGGER = void 0;
+exports.PUBLISHER_LOGGER = {
+    log: (...args) => {
+        if (process.env['DEBUG_LOGGING_ENABLED'] === 'TRUE') {
+            console.log(...args);
+        }
+    },
+    warn: (...args) => {
+        console.warn(...args);
+    },
+    error: (...args) => {
+        console.warn(...args);
+    },
+};
+exports.PERFORMANCE_LOGGER = {
+    log: (...args) => {
+        if (process.env['PERFORMANCE_LOGGING_ENABLED'] !== 'FALSE') {
+            console.log(...args);
+        }
+    },
+};

package/src/lib/redis/registry.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setRedisConnectionSettings = exports.RedisRegistry = void 0;
 const ioredis_1 = require("ioredis");
+const logger_1 = require("./logger");
 class RedisRegistry {
     static attemptConnection(connectionKey, storeRef = 0) {
         let ref;
@@ -25,8 +26,9 @@ class RedisRegistry {
     }
     static handleDisconnects(connection, connectionKey, storeRef) {
         connection.on('error', (error) => {
-            console.error(`PUBLISHER: Redis connection error : ${error.message}`);
+            logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Redis connection error : ${error.message}`);
             connection.removeAllListeners();
+            connection.disconnect();
             RedisRegistry.attemptConnection(connectionKey, storeRef);
         });
     }
@@ -42,7 +44,7 @@ class RedisRegistry {
             ]);
             if (res === 'NO_PING') {
                 connection.disconnect(true);
-                console.error('PUBLISHER: failed to ping redis, disconnecting and restarting service.');
+                logger_1.PUBLISHER_LOGGER.error('PUBLISHER: failed to ping redis, disconnecting and restarting service.');
                 process.exit(0);
             }
         }, 2000);

package/src/lib/redis/scheduler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduledProcessor = void 0;
 const id_1 = require("@jetit/id");
 const rxjs_1 = require("rxjs");
+const logger_1 = require("./logger");
 const registry_1 = require("./registry");
 const utils_1 = require("./utils");
 /**
@@ -18,27 +19,27 @@ class ScheduledProcessor {
     constructor(duration = 1000) {
         this.previousTaskCompleted = true;
         this.scheduledMessagesTimer = (0, rxjs_1.interval)(duration).subscribe(() => {
-            console.log('Checking Streams messages at ', new Date().toISOString(), '...');
+            logger_1.PUBLISHER_LOGGER.log('Checking Streams messages at ', new Date().toISOString(), '...');
             /** Do not run scheduler if the previous run is not completed */
             if (this.previousTaskCompleted) {
                 this.previousTaskCompleted = false;
                 this.processScheduledEvents()
                     .catch((error) => {
-                    console.error('Error while processing scheduled events:', error);
+                    logger_1.PUBLISHER_LOGGER.error('Error while processing scheduled events:', error);
                 })
                     .then(() => {
                     this.previousTaskCompleted = true;
                 });
             }
             else {
-                console.log('Skipping current scheduler run because previous run is in progress');
+                logger_1.PUBLISHER_LOGGER.log('Skipping current scheduler run because previous run is in progress');
             }
         });
     }
     async processScheduledEvents() {
         const currentTime = new Date().getTime();
         const events = await this.redisPublisher.zrangebyscore('se', 0, currentTime);
-        console.log('Events to process:', events.length);
+        logger_1.PUBLISHER_LOGGER.log('Events to process:', events.length);
         for (const eventString of events) {
             const eventData = (0, utils_1.decodeScheduledMessage)(eventString);
             /**
@@ -52,14 +53,14 @@ class ScheduledProcessor {
             eventData.eventId = (0, id_1.generateID)('HEX', 'FF');
             await this.redisPublisher.zrem('se', eventString);
             const consumerGroups = await (0, utils_1.getAllConsumerGroups)(eventData.eventName, this.redisPublisher);
-            console.log('Scheduled Publishing to consumer groups: ', consumerGroups, 'with id ', eventData.eventId, '...');
+            logger_1.PUBLISHER_LOGGER.log('Scheduled Publishing to consumer groups: ', consumerGroups, 'with id ', eventData.eventId, '...');
             let key = '*';
             for (const consumerGroup of consumerGroups) {
                 // Publish the event to each consumer group's stream
                 const streamName = `${eventData.eventName}:${consumerGroup}`;
                 const generatedKey = await this.redisPublisher
                     .xadd(streamName, '*', 'data', JSON.stringify(eventData))
-                    .catch((e) => console.error(`PUBLISHER: Publishing event ${eventData.eventName} to consumer groups: ${consumerGroups.join(', ')} failed with data ${JSON.stringify(eventData)}, ${e} `));
+                    .catch((e) => logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Publishing event ${eventData.eventName} to consumer groups: ${consumerGroups.join(', ')} failed with data ${JSON.stringify(eventData)}, ${e} `));
                 if (key === '*')
                     key = generatedKey ?? key;
             }

package/src/lib/redis/streams.d.ts

@@ -43,10 +43,11 @@ export declare class Streams {
      * const eventData = { eventName: 'order.created', data: orderData };
      * await streams.publish(eventData);
      */
-    publish<TData = unknown, TName extends string = string>(data: PublishData<TData, TName>): Promise<void>;
+    publish<TData = unknown, TName extends string = string>(data: PublishData<TData, TName>, multicast?: boolean): Promise<string>;
     /**
      * Schedules an event to be published at a specified future time. Thee event gets published if the
-     * differnece between the current time and the scheduled time is less than 500ms.
+     * differnece between the current time and the scheduled time is less than 500ms. The granularity
+     * of scheduled publish is 5 seconds. So it doesnt make sense to run anything less than the 5 secs time
      *
      * @param scheduledTime - The Date object representing the future time when the event should be published.
      * @param eventData - The event data object, containing the event name and its associated data.
@@ -67,7 +68,7 @@ export declare class Streams {
      *
      * await streams.scheduledPublish(futureTime, eventData);
      */
-    scheduledPublish<TData = unknown, TName extends string = string>(scheduledTime: Date, eventData: PublishData<TData, TName>, uniquePerInstance?: boolean, repeatInterval?: number): Promise<void>;
+    scheduledPublish<TData = unknown, TName extends string = string>(scheduledTime: Date, eventData: PublishData<TData, TName>, uniquePerInstance?: boolean, repeatInterval?: number, multicast?: boolean): Promise<void>;
     /**
      * Listens for events with the given name and returns an Observable that emits an EventData<T> object
      * each time a new event is received.
@@ -75,7 +76,7 @@ export declare class Streams {
      * The method uses a BehaviorSubject to emit the events as Observables. The BehaviorSubject ensures
      * that new subscribers receive the last emitted event, even if they subscribe after the event has been emitted.
      *
-     * If an error occurs while subscribing, the method logs the error to the console and throws
+     * If an error occurs while subscribing, the method logs the error to the PUBLISHER_LOGGER and throws
      * an error. This is done to prevent the service from continuing without a proper event subscription.
      *
      * There is retry logic with exponential backoff to handle error cases. These are also controllable by the
@@ -92,7 +93,7 @@ export declare class Streams {
      *
      * // Subscribe to the Observable and log each new event
      * orderCreated.subscribe((event) => {
-     *   console.log('New order created:', event.data);
+     *   PUBLISHER_LOGGER.log('New order created:', event.data);
      * });
      */
     listen<T = unknown, const TName extends string = string>(eventName: TName, maxRetries?: number, initialDelay?: number): Observable<EventData<T, TName>>;
@@ -108,16 +109,26 @@ export declare class Streams {
      * process.on('SIGINT', shutdown);
      *
      * async function shutdown(): Promise<void> {
-     *   console.log('Graceful shutdown initiated.');
+     *   PUBLISHER_LOGGER.log('Graceful shutdown initiated.');
      *   try {
      *     await streams.close();
-     *     console.log('Resources and connections successfully closed.');
+     *     PUBLISHER_LOGGER.log('Resources and connections successfully closed.');
      *   } catch (error) {
-     *     console.error('Error during graceful shutdown:', error);
+     *     PUBLISHER_LOGGER.error('Error during graceful shutdown:', error);
      *   }
      *   process.exit(0);
      * }
      */
     close(): Promise<void>;
     private cleanupAcknowledgedMessages;
+    /**
+     * This function should be added to Surf Signal to publish periodic diagnostic information
+     * on the health of the stream
+     */
+    getUnacknowledgedMessagesForStream(eventName: string): Promise<{
+        count: number;
+        countOnThisConsumer?: number | undefined;
+        messageIds: string[];
+        messages?: unknown[] | undefined;
+    }>;
 }

package/src/lib/redis/streams.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Streams = void 0;
 const id_1 = require("@jetit/id");
 const rxjs_1 = require("rxjs");
+const logger_1 = require("./logger");
 const registry_1 = require("./registry");
 const utils_1 = require("./utils");
 function publisherErrorHandler(error) {
-    console.error('PUBLISHER UNHANDLED ERROR: ', JSON.stringify(error));
+    logger_1.PUBLISHER_LOGGER.error('PUBLISHER UNHANDLED ERROR: ', JSON.stringify(error));
 }
 class Streams {
     get redisPublisher() {
@@ -38,23 +39,24 @@ class Streams {
         this.instanceUniqueId = process.env['INSTANCE_ID'] ?? (0, id_1.generateID)('HEX', 'FE');
         this.instanceId = `${serviceName}:${this.instanceUniqueId}`;
         this.consumerGroupName = `cg-${serviceName}`;
-        console.log(`PUBLISHER: Instance ID: ${this.instanceId}`);
+        logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Instance ID: ${this.instanceId}`);
         const cleanUpInterval = parseInt(process.env['CLEANUP_INTERVAL'] || `${1000 * 60 * 60}`, 10) ?? 1000 * 60 * 60;
         this.cleanUpTimer = setInterval(() => {
             this.runClear(cleanUpInterval);
         }, cleanUpInterval);
     }
     async runClear(cleanUpInterval) {
-        console.log('PUBLISHER: Running Clearance', this.eventsListened);
+        logger_1.PUBLISHER_LOGGER.log('PUBLISHER: Running Clearance', this.eventsListened);
         for (const eventName of this.eventsListened) {
             process.nextTick(async () => {
                 /** This removes the messages from the stream after they have been processed according to cleanup interval */
                 await this.cleanupAcknowledgedMessages(eventName, cleanUpInterval).catch(publisherErrorHandler);
-                console.log(`Cleanup process for Acknowledged messages completed for ${eventName}`);
+                logger_1.PUBLISHER_LOGGER.log(`Cleanup process for Acknowledged messages completed for ${eventName}`);
             });
         }
     }
-    async publish(data) {
+    async publish(data, multicast = false) {
+        const publishStartTime = process.hrtime();
         if (data.eventId)
             data.republishEvent = data.eventId;
         data.eventId = (0, id_1.generateID)('HEX', 'FF');
@@ -63,28 +65,32 @@ class Streams {
         const consumerGroups = await (0, utils_1.getAllConsumerGroups)(data.eventName, this.redisPublisher);
         let key = '*';
         if (consumerGroups.length > 0) {
-            console.log(`PUBLISHER: Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')}`);
+            logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')}`);
             try {
                 for (const consumerGroup of consumerGroups) {
                     // Publish the event to each consumer group's stream
                     const streamName = `${data.eventName}:${consumerGroup}`;
                     const generatedKey = await this.redisPublisher
                         .xadd(streamName, key, 'data', JSON.stringify(data))
-                        .catch((e) => console.error(`PUBLISHER: Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')} failed with data ${JSON.stringify(data)}, ${e} `));
+                        .catch((e) => logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')} failed with data ${JSON.stringify(data)}, ${e} `));
                     if (key === '*')
                         key = generatedKey ?? key;
                 }
-                await (0, utils_1.notifySubscribers)(this.redisPublisher, data.eventName, key);
+                await (0, utils_1.notifySubscribers)(this.redisPublisher, data.eventName, key, multicast);
             }
             catch (error) {
-                console.error(`PUBLISHER: Error while publishing event for service ${this.consumerGroupName} with instance ${this.instanceId}: `, error);
+                logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error while publishing event for service ${this.consumerGroupName} with instance ${this.instanceId}: `, error);
                 throw new Error('Publisher Error');
             }
         }
         else
-            console.log(`PUBLISHER: Event publish failed for event ${data.eventName}, reason: no consumers ${consumerGroups}`);
+            logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Event publish failed for event ${data.eventName}, reason: no consumers ${consumerGroups}`);
+        const publishEndTime = process.hrtime(publishStartTime);
+        const elapsedTime = publishEndTime[0] * 1000 + publishEndTime[1] / 1000000;
+        logger_1.PERFORMANCE_LOGGER.log(`PTIME;${key};${data.eventName};${Date.now()};${elapsedTime}`);
+        return key;
     }
-    async scheduledPublish(scheduledTime, eventData, uniquePerInstance = false, repeatInterval = 0) {
+    async scheduledPublish(scheduledTime, eventData, uniquePerInstance = false, repeatInterval = 0, multicast = false) {
         const currentTime = new Date();
         delete eventData.repeatInterval;
         if (repeatInterval > 0) {
@@ -94,14 +100,14 @@ class Streams {
             throw new Error('PUBLISHER: Cannot schedule an event in the past');
         }
         else if (Math.abs(scheduledTime.getTime() - currentTime.getTime()) <= 500) {
-            await this.publish(eventData);
+            await this.publish(eventData, multicast);
         }
         else {
             const key = (0, utils_1.encodeScheduledMessage)(eventData);
             if (uniquePerInstance === true) {
                 const existingJob = await this.redisPublisher.zscore('se', key);
                 if (existingJob) {
-                    console.log(`PUBLISHER: Job with data '${eventData}' already exists. Skipping.`);
+                    logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Job with data '${eventData}' already exists. Skipping.`);
                     return;
                 }
             }
@@ -115,7 +121,7 @@ class Streams {
      * The method uses a BehaviorSubject to emit the events as Observables. The BehaviorSubject ensures
      * that new subscribers receive the last emitted event, even if they subscribe after the event has been emitted.
      *
-     * If an error occurs while subscribing, the method logs the error to the console and throws
+     * If an error occurs while subscribing, the method logs the error to the PUBLISHER_LOGGER and throws
      * an error. This is done to prevent the service from continuing without a proper event subscription.
      *
      * There is retry logic with exponential backoff to handle error cases. These are also controllable by the
@@ -132,7 +138,7 @@ class Streams {
      *
      * // Subscribe to the Observable and log each new event
      * orderCreated.subscribe((event) => {
-     *   console.log('New order created:', event.data);
+     *   PUBLISHER_LOGGER.log('New order created:', event.data);
      * });
      */
     listen(eventName, maxRetries = 5, initialDelay = 1000) {
@@ -140,11 +146,11 @@ class Streams {
             count: maxRetries,
             delay: (error, retryAttempt) => {
                 const delay = initialDelay * Math.pow(2, retryAttempt);
-                console.error(`PUBLISHER: Error in listen: ${error.message}. Retrying in ${delay}ms (attempt ${retryAttempt + 1})`);
+                logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error in listen: ${error.message}. Retrying in ${delay}ms (attempt ${retryAttempt + 1})`);
                 return (0, rxjs_1.timer)(delay);
             },
         }), (0, rxjs_1.catchError)((error) => {
-            console.error(`PUBLISHER: Error in listen after ${maxRetries} retries: ${error.message}`);
+            logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error in listen after ${maxRetries} retries: ${error.message}`);
             return (0, rxjs_1.throwError)(() => new Error(error.message));
         }));
     }
@@ -156,61 +162,88 @@ class Streams {
         await this.redisGroups
             .xgroup('CREATE', streamName, this.consumerGroupName, '0', 'MKSTREAM')
             .then(() => {
-            console.log(`Group created created for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
+            logger_1.PUBLISHER_LOGGER.log(`Group created created for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
         })
             .catch((e) => {
-            console.error(`PUBLISHER: Group creation failed with error ${e.message} for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
+            logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Group creation failed with error ${e.message} for ${JSON.stringify({ streamName, cgn: this.consumerGroupName })}`);
         });
         const createConsumerStatus = (await this.redisGroups.xgroup('CREATECONSUMER', streamName, this.consumerGroupName, this.instanceId));
         await this.redisGroups.sadd(key, eventName);
         const addToCGSet = await this.redisGroups.sadd(`${eventName}`, this.consumerGroupName);
         const addToFlushSet = await this.redisGroups.set(setKeyForK8sHandling, this.consumerGroupName);
-        console.log(`PUBLISHER: Consumer Registered and created with ${this.instanceId} under ${this.consumerGroupName} with ${createConsumerStatus} consumers and with the following status ${JSON.stringify({ addToCGSet, addToFlushSet })}`);
+        logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Consumer Registered and created with ${this.instanceId} under ${this.consumerGroupName} with ${createConsumerStatus} consumers and with the following status ${JSON.stringify({ addToCGSet, addToFlushSet })}`);
         return createConsumerStatus === 0 || createConsumerStatus === 1;
     }
     listenInternals(eventName) {
         const bs = new rxjs_1.BehaviorSubject(null);
-        const observable = bs.asObservable().pipe((0, rxjs_1.skip)(1));
+        const timer = (0, rxjs_1.interval)(10000).subscribe(async () => {
+            /** Clear earlier unprocessed messages. Runs every 10 seconds */
+            await processMessage(this.redisGroups, '0', false);
+        });
+        const observable = bs.asObservable().pipe((0, rxjs_1.skip)(1), (0, rxjs_1.finalize)(() => {
+            /** Cleanup timer */
+            timer.unsubscribe();
+        }));
         const streamName = `${eventName}:${this.consumerGroupName}`;
-        const processMessage = async (redisClient, messageId, processPending = false) => {
-            console.log(`PUBLISHER: Processing message ${messageId} for ${streamName}`);
+        const processMessage = async (redisClient, messageId, multicast = false, processPending = false) => {
+            logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Processing message ${messageId} for ${streamName}`);
             try {
                 try {
-                    const pendingDetails = await redisClient.xpending(streamName, this.consumerGroupName, messageId, messageId, 1, this.instanceId);
-                    if (pendingDetails[2] === 0) {
-                        console.warn(`PUBLISHER: Message ${messageId} for ${streamName} already acknowledged.`);
+                    /**
+                     * Check if the message is already acquired by another client and is pending.
+                     */
+                    const pendingDetails = await redisClient.xpending(streamName, this.consumerGroupName, messageId, messageId, 1);
+                    if (pendingDetails[2] === 0 && multicast === false) {
+                        logger_1.PUBLISHER_LOGGER.warn(`PUBLISHER: MACK ${messageId} for ${streamName}`);
                         return;
                     }
                 }
                 catch (e) {
                     // Ignore the xpending error and continue
-                    console.error('XPENDING ERROR: To be handled');
-                    console.warn(JSON.stringify(e));
+                    logger_1.PUBLISHER_LOGGER.error('XPENDING ERROR: To be handled');
+                    logger_1.PUBLISHER_LOGGER.warn(JSON.stringify(e));
+                }
+                let eventData;
+                /**
+                 * Both multicast messages and pending messages cannot be read by xreadgroup
+                 * Multicast messages should not be claimed by a single consumer. And pending messages
+                 * are usually behind in the stream so XREADGROUP will not read them and hence
+                 * they need to be read using XRANGE.
+                 */
+                if (multicast === true || processPending) {
+                    const messages = await redisClient.xrange(streamName, messageId, messageId);
+                    if (messages && messages.length) {
+                        eventData = JSON.parse(messages[0][1][1]);
+                    }
                 }
-                const messages = await redisClient.xrange(streamName, messageId, messageId);
-                if (messages && messages.length) {
-                    const eventData = JSON.parse(messages[0][1][1]);
+                else {
+                    const messages = (await redisClient.xreadgroup('GROUP', this.consumerGroupName, this.instanceId, 'COUNT', 1, 'STREAMS', streamName, '>'));
+                    if (messages && messages.length) {
+                        eventData = JSON.parse(messages[0][1][0][1][1]);
+                    }
+                }
+                if (eventData) {
                     bs.next(eventData);
                     await redisClient.xack(streamName, this.consumerGroupName, messageId);
                     await redisClient.zadd(`ack:${streamName}`, Date.now().toString(), messageId);
                 }
                 else {
-                    console.warn(`PUBLISHER: Message ${messageId} not found for ${streamName}`);
+                    logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Message ${messageId} not found for ${streamName}`);
                 }
                 /** Process Unprocessed Message if this is a main tree, otherwise limit to processing 100 messages that are unacknowledged */
                 if (!processPending) {
-                    const unprocessedMessageIds = await (0, utils_1.getUnacknowledgedMessages)(redisClient, this.consumerGroupName, streamName, 25);
-                    if (unprocessedMessageIds.count > 25) {
-                        console.error(`PUBLISHER: Too many unprocessed events for ${streamName}: count: ${unprocessedMessageIds.count}`);
+                    const unprocessedMessageIds = await (0, utils_1.getUnacknowledgedMessages)(redisClient, this.consumerGroupName, streamName, this.instanceId);
+                    if (unprocessedMessageIds.countOnThisConsumer && unprocessedMessageIds.countOnThisConsumer > 25) {
+                        logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Too many unprocessed events for ${streamName}: count: ${unprocessedMessageIds.count}`);
                     }
                     for (const id of unprocessedMessageIds.messageIds) {
-                        console.log(`PUBLISHER: Reporcessing unprocessed message with id: ${id}`);
-                        await processMessage(redisClient, id, true);
+                        logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Reporcessing unprocessed message with id: ${id}`);
+                        await processMessage(redisClient, id, multicast, true);
                     }
                 }
             }
             catch (e) {
-                console.error(`PUBLISHER: Error processing message ${messageId} for ${streamName}`, e);
+                logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error processing message ${messageId} for ${streamName}`, e);
             }
         };
         /** Register the consumer and setup the Observable */
@@ -220,15 +253,20 @@ class Streams {
                 throw new Error('PUBLISHER: Cannot setup consumer');
             const eventStreamClient = registry_1.RedisRegistry.getConnection(`sub-${eventName}`);
             eventStreamClient.subscribe(eventName).then(() => {
-                console.log(`PUBLISHER: Redis Subscription connection initiated for ${eventName}`);
+                logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Redis Subscription connection initiated for ${eventName}`);
             });
-            eventStreamClient.on('message', async (channel, messageId) => {
-                console.log(`PUBLISHER: Stream Notification Received for event ${eventName} with message ID ${messageId}`);
-                await processMessage(this.redisGroups, messageId);
+            eventStreamClient.on('message', async (channel, data) => {
+                const subscribeStartTime = process.hrtime();
+                const { messageId, multicast } = JSON.parse(data);
+                logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Stream Notification Received for event ${eventName} with message ID ${messageId}`);
+                await processMessage(this.redisGroups, messageId, multicast);
+                const subscribendTime = process.hrtime(subscribeStartTime);
+                const elapsedTime = subscribendTime[0] * 1000 + subscribendTime[1] / 1000000;
+                logger_1.PERFORMANCE_LOGGER.log(`STIME;${messageId};${data.eventName};${Date.now()};${elapsedTime}`);
             });
         })
             .catch((e) => {
-            console.error(`PUBLISHER: Error during consumer registration for ${eventName}`, e);
+            logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error during consumer registration for ${eventName}`, e);
         });
         return observable;
     }
@@ -242,12 +280,12 @@ class Streams {
      * process.on('SIGINT', shutdown);
      *
      * async function shutdown(): Promise<void> {
-     *   console.log('Graceful shutdown initiated.');
+     *   PUBLISHER_LOGGER.log('Graceful shutdown initiated.');
      *   try {
      *     await streams.close();
-     *     console.log('Resources and connections successfully closed.');
+     *     PUBLISHER_LOGGER.log('Resources and connections successfully closed.');
      *   } catch (error) {
-     *     console.error('Error during graceful shutdown:', error);
+     *     PUBLISHER_LOGGER.error('Error during graceful shutdown:', error);
      *   }
      *   process.exit(0);
      * }
@@ -279,5 +317,14 @@ class Streams {
             await this.redisGroups.zremrangebyscore(`ack:${streamName}`, '-inf', cleanupThreshold);
         }
     }
+    /**
+     * This function should be added to Surf Signal to publish periodic diagnostic information
+     * on the health of the stream
+     */
+    async getUnacknowledgedMessagesForStream(eventName) {
+        const streamName = `${eventName}:${this.consumerGroupName}`;
+        const unprocessedMessageIds = await (0, utils_1.getUnacknowledgedMessages)(this.redisGroups, this.consumerGroupName, streamName, this.instanceId);
+        return unprocessedMessageIds;
+    }
 }
 exports.Streams = Streams;

package/src/lib/redis/utils.d.ts

@@ -1,8 +1,9 @@
 import { RedisType } from './registry';
 import { EventData } from './types';
 export declare function getAllConsumerGroups(eventName: string, redisConnection: RedisType): Promise<string[]>;
-export declare function getUnacknowledgedMessages(redisClient: RedisType, consumerGroupName: string, streamName: string, count?: number): Promise<{
+export declare function getUnacknowledgedMessages(redisClient: RedisType, consumerGroupName: string, streamName: string, consumerName: string, count?: number): Promise<{
     count: number;
+    countOnThisConsumer?: number;
     messageIds: string[];
     messages?: unknown[];
 }>;
@@ -10,7 +11,7 @@ export declare function getMessageStatesCount(redisClient: RedisType, streamName
     acknowledged: number;
     unacknowledged: number;
 }>;
-export declare function notifySubscribers(redisClient: RedisType, eventName: string, messageId: string): Promise<void>;
+export declare function notifySubscribers(redisClient: RedisType, eventName: string, messageId: string, multicast?: boolean): Promise<void>;
 export declare function removedScheduledJob(redisClient: RedisType, eventString: string): Promise<void>;
 export declare function encodeScheduledMessage<TData, TName extends string>(data: EventData<TData, TName>): string;
 export declare function decodeScheduledMessage(data: string): EventData<never, never>;

package/src/lib/redis/utils.js

@@ -1,31 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UTILS = exports.decodeScheduledMessage = exports.encodeScheduledMessage = exports.removedScheduledJob = exports.notifySubscribers = exports.getMessageStatesCount = exports.getUnacknowledgedMessages = exports.getAllConsumerGroups = void 0;
+const logger_1 = require("./logger");
 async function getAllConsumerGroups(eventName, redisConnection) {
     const consumerGroups = await redisConnection.smembers(`${eventName}`);
     return consumerGroups;
 }
 exports.getAllConsumerGroups = getAllConsumerGroups;
-async function getUnacknowledgedMessages(redisClient, consumerGroupName, streamName, count = 500) {
+async function getUnacknowledgedMessages(redisClient, consumerGroupName, streamName, consumerName, count = 500) {
     try {
         // Get pending messages summary
         const summary = await redisClient.xpending(streamName, consumerGroupName);
-        if (!summary || summary[1] === 0) {
+        if (!summary || summary[0] === 0) {
             // If count is zero
             return { count: 0, messageIds: [] };
         }
         // Use the smallest and largest IDs to get a detailed range
-        const pendingMessageCount = summary[1];
+        const pendingMessageCount = summary[0];
         // Get detailed information in the range
-        const pendingMessages = (await redisClient.xpending(streamName, consumerGroupName, '-', '+', count));
+        let pendingMessages = (await redisClient.xpending(streamName, consumerGroupName, '-', '+', count, consumerName));
+        /** If no pending messages on consumer, fetch messages from other consumers that haven't been claimed for more than 10s */
+        if (count > pendingMessages.length && pendingMessages.length === 0) {
+            await redisClient.xautoclaim(streamName, consumerGroupName, consumerName, 10000, '0-0', 'COUNT', 100);
+            pendingMessages = (await redisClient.xpending(streamName, consumerGroupName, '-', '+', count, consumerName));
+        }
         return {
             count: pendingMessageCount,
+            countOnThisConsumer: pendingMessages.length,
             messageIds: pendingMessages.map((message) => message[0]),
             messages: pendingMessages,
         };
     }
     catch (error) {
-        console.error(`PUBLISHER: Error fetching unacknowledged messages for ${streamName}`, error);
+        logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error fetching unacknowledged messages for ${streamName}`, error);
         return { count: 0, messageIds: [] };
     }
 }
@@ -40,22 +47,22 @@ async function getMessageStatesCount(redisClient, streamName, consumerGroup) {
         };
     }
     catch (error) {
-        console.error(`PUBLISHER: Error fetching message states count for ${streamName}`, error);
+        logger_1.PUBLISHER_LOGGER.error(`PUBLISHER: Error fetching message states count for ${streamName}`, error);
         return { acknowledged: 0, unacknowledged: 0 };
     }
 }
 exports.getMessageStatesCount = getMessageStatesCount;
-async function notifySubscribers(redisClient, eventName, messageId) {
-    await redisClient.publish(eventName, messageId);
+async function notifySubscribers(redisClient, eventName, messageId, multicast = false) {
+    await redisClient.publish(eventName, JSON.stringify({ messageId, multicast }));
 }
 exports.notifySubscribers = notifySubscribers;
 async function removedScheduledJob(redisClient, eventString) {
     const currentTime = new Date().getTime();
     const events = await redisClient.zrangebyscore('se', 0, currentTime);
-    console.log(`Total Events in scheduled queue: ${events.length}`);
+    logger_1.PUBLISHER_LOGGER.log(`Total Events in scheduled queue: ${events.length}`);
     await redisClient.zrem('se', eventString);
     const eventsLater = await redisClient.zrangebyscore('se', 0, currentTime);
-    console.log(`Total Events in scheduled queue: ${eventsLater.length}`);
+    logger_1.PUBLISHER_LOGGER.log(`Total Events in scheduled queue: ${eventsLater.length}`);
 }
 exports.removedScheduledJob = removedScheduledJob;
 function encodeScheduledMessage(data) {