@jetit/publisher 4.0.0 → 4.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetit/publisher",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "type": "commonjs",
   "dependencies": {
     "@jetit/id": "^0.0.12",

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

@@ -121,14 +121,25 @@ export declare class Streams {
      */
     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;
+    getDiagnosticData(events: string[]): Promise<{
+        status: string;
+        message: string;
+        data?: undefined;
+    } | {
+        status: string;
+        data: {
+            eventName: string;
+            consumerGroupMap: {
+                consumerGroup: string;
+                diagnostics: Generator<Promise<unknown[]> | {
+                    count: number;
+                    consumers: {
+                        consumerName: string;
+                        pendingCount: string;
+                    }[];
+                }, void, [number, string, string, string[][]]>;
+            }[];
+        }[];
+        message: string;
     }>;
 }

package/src/lib/redis/streams.js

@@ -257,12 +257,21 @@ class Streams {
             });
             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);
+                let messageIdRead, multicastRead;
+                try {
+                    const { messageId, multicast } = JSON.parse(data);
+                    messageIdRead = messageId;
+                    multicastRead = multicast;
+                }
+                catch (e) {
+                    messageIdRead = data;
+                    multicastRead = false;
+                }
+                logger_1.PUBLISHER_LOGGER.log(`PUBLISHER: Stream Notification Received for event ${eventName} with message ID ${messageIdRead}`);
+                await processMessage(this.redisGroups, messageIdRead, multicastRead);
                 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}`);
+                logger_1.PERFORMANCE_LOGGER.log(`STIME;${messageIdRead};${data.eventName};${Date.now()};${elapsedTime}`);
             });
         })
             .catch((e) => {
@@ -317,14 +326,21 @@ 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;
+    async getDiagnosticData(events) {
+        if (events.length > 100) {
+            return { status: 'ERROR', message: 'Please pass in a maximum of 100 elements to fetch diagnostics' };
+        }
+        const tempPromises = events.map(async (eventName) => {
+            const consumerGroups = await (0, utils_1.getAllConsumerGroups)(eventName, this.redisPublisher);
+            const consumerGroupMap = await Promise.all(consumerGroups.map(async (consumerGroup) => {
+                const streamName = `${eventName}:${consumerGroup}`;
+                const diagnostics = await (0, utils_1.getSummaryOnStreamConsumerGroup)(this.redisGroups, consumerGroup, streamName);
+                return { consumerGroup, diagnostics };
+            }));
+            return { eventName, consumerGroupMap };
+        });
+        const returnData = await await Promise.all(tempPromises);
+        return { status: 'SUCCESS', data: returnData, message: 'We recommend not running this in times of heavy load' };
     }
 }
 exports.Streams = Streams;

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

@@ -1,6 +1,13 @@
 import { RedisType } from './registry';
 import { EventData } from './types';
 export declare function getAllConsumerGroups(eventName: string, redisConnection: RedisType): Promise<string[]>;
+export declare function getSummaryOnStreamConsumerGroup(redisClient: RedisType, consumerGroupName: string, streamName: string): Generator<Promise<unknown[]> | {
+    count: number;
+    consumers: {
+        consumerName: string;
+        pendingCount: string;
+    }[];
+}, void, [number, string, string, string[][]]>;
 export declare function getUnacknowledgedMessages(redisClient: RedisType, consumerGroupName: string, streamName: string, consumerName: string, count?: number): Promise<{
     count: number;
     countOnThisConsumer?: number;

package/src/lib/redis/utils.js

@@ -1,12 +1,27 @@
 "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;
+exports.UTILS = exports.decodeScheduledMessage = exports.encodeScheduledMessage = exports.removedScheduledJob = exports.notifySubscribers = exports.getMessageStatesCount = exports.getUnacknowledgedMessages = exports.getSummaryOnStreamConsumerGroup = 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;
+function* getSummaryOnStreamConsumerGroup(redisClient, consumerGroupName, streamName) {
+    const [count, , , consumers] = (yield redisClient.xpending(streamName, consumerGroupName));
+    yield {
+        count,
+        consumers: consumers
+            ? consumers.map((x) => {
+                return {
+                    consumerName: x[0],
+                    pendingCount: x[1],
+                };
+            })
+            : [],
+    };
+}
+exports.getSummaryOnStreamConsumerGroup = getSummaryOnStreamConsumerGroup;
 async function getUnacknowledgedMessages(redisClient, consumerGroupName, streamName, consumerName, count = 500) {
     try {
         // Get pending messages summary