@palmetto/pubsub 3.0.2 → 3.1.0

package/dist/bullmq/publisher.js

@@ -41,18 +41,19 @@ class BullMqPublisher {
             var _a, _b;
             const queue = yield this.getQueue(config);
             (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publishing ${messages.length} messages to ${queue.name}`);
+            const opts = {
+                delay: (options === null || options === void 0 ? void 0 : options.scheduledAt)
+                    ? Math.max(0, options.scheduledAt.getTime() - Date.now())
+                    : undefined,
+                attempts: config.retries !== undefined ? config.retries + 1 : undefined,
+                backoff: {
+                    type: "fixed",
+                    delay: config.retryDelay || 30000,
+                },
+            };
             const job = {
                 name: config.job || connection_js_1.BULLMQ_DEFAULTJOB,
-                opts: {
-                    delay: (options === null || options === void 0 ? void 0 : options.scheduledAt)
-                        ? Math.max(0, options.scheduledAt.getTime() - Date.now())
-                        : undefined,
-                    attempts: config.retries,
-                    backoff: {
-                        type: "fixed",
-                        delay: config.retryDelay || 30000,
-                    },
-                },
+                opts,
             };
             const jobs = messages.map((data) => {
                 return Object.assign(Object.assign({}, job), { data });

package/dist/bullmq/subscriber.d.ts

@@ -9,9 +9,11 @@ declare class SubscribedMessage {
     stopSubscribe(): Promise<void>;
 }
 export declare class MessageFailError extends Error {
+    static readonly failedReason = "Handler asked to fail this job";
     constructor();
 }
 export declare class MessageRetryError extends Error {
+    static readonly failedReason = "Handler asked to retry this job";
     constructor();
 }
 export declare class BullMqSubscriber implements SubscriberProvider {
@@ -24,5 +26,6 @@ export declare class BullMqSubscriber implements SubscriberProvider {
     startSubscribe(config: BullMqQueueConfiguration, onMessage: (s: string, context: BullMqMessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe>;
     close(): Promise<void>;
     enrichHandledMesssageLog(config: BullMqQueueConfiguration): Record<string, unknown>;
+    willRetryJobOnFailure(job: bullmq.Job<string>): boolean;
 }
 export {};

package/dist/bullmq/subscriber.js

@@ -32,16 +32,18 @@ class SubscribedMessage {
 }
 class MessageFailError extends Error {
     constructor() {
-        super("Handler asked to fail this job");
+        super(MessageFailError.failedReason);
     }
 }
 exports.MessageFailError = MessageFailError;
+MessageFailError.failedReason = "Handler asked to fail this job";
 class MessageRetryError extends Error {
     constructor() {
-        super("Handler asked to retry this job");
+        super(MessageRetryError.failedReason);
     }
 }
 exports.MessageRetryError = MessageRetryError;
+MessageRetryError.failedReason = "Handler asked to retry this job";
 class BullMqSubscriber {
     constructor(connection, logger) {
         this.connection = connection;
@@ -70,9 +72,10 @@ class BullMqSubscriber {
                 }, () => __awaiter(this, void 0, void 0, function* () {
                     const context = {
                         job: job.name,
-                        retries: job.attemptsMade,
+                        attemptsMade: job.attemptsMade,
                         firstSent: new Date(job.timestamp),
-                        // lastSent: new Date(job.attemptsStarted),
+                        lastSent: undefined,
+                        willRetryOnFailure: this.willRetryJobOnFailure(job),
                     };
                     const result = yield onMessage(job.data, context);
                     if (result === interfaces_js_1.MessageResult.Ok) {
@@ -81,7 +84,8 @@ class BullMqSubscriber {
                     if (result === interfaces_js_1.MessageResult.Retry) {
                         throw new MessageRetryError();
                     }
-                    throw new BullMqPackage.UnrecoverableError("Handler asked to fail this job");
+                    // result === MessageResult.Fail
+                    throw new BullMqPackage.UnrecoverableError(MessageFailError.failedReason);
                 }));
             }), {
                 connection: this.connection,
@@ -91,10 +95,30 @@ class BullMqSubscriber {
                 if (!job) {
                     return;
                 }
-                this.logger.log(`Job failed ${err}`);
+                if (job.failedReason !== MessageRetryError.failedReason &&
+                    job.failedReason !== MessageFailError.failedReason) {
+                    const log = {
+                        message: "BullMq PubSub job failed",
+                        error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
+                        extra: {
+                            job: config.name,
+                            message: job.data,
+                            attemptsMade: job.attemptsMade,
+                            failedReason: job.failedReason,
+                        },
+                    };
+                    this.logger.error(log);
+                }
             });
             worker.on("error", (err) => {
-                this.logger.error(`BullMq PubSub handler exception: ${err}`);
+                const log = {
+                    message: "BullMq PubSub handler exception",
+                    error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
+                    extra: {
+                        job: config.name,
+                    },
+                };
+                this.logger.error(log);
             });
             (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `BullMq PubSub subscriber starting for ${worker.name}`);
             worker
@@ -128,5 +152,9 @@ class BullMqSubscriber {
             job: config.job,
         };
     }
+    willRetryJobOnFailure(job) {
+        var _a;
+        return job.attemptsMade + 1 < ((_a = job.opts.attempts) !== null && _a !== void 0 ? _a : 1);
+    }
 }
 exports.BullMqSubscriber = BullMqSubscriber;

package/dist/interfaces.d.ts

@@ -52,7 +52,7 @@ export interface PubSubConfiguration {
      */
     transport: string;
     /**
-     * Maximum number of times to retry a message
+     * Maximum number of times to retry a message (default: 0, no retries)
      */
     retries?: number;
     /**
@@ -129,7 +129,8 @@ export type PubSubProvider = PublisherProvider & SubscriberProvider;
  */
 export type PubOrSubProvider = PubSubProvider | PublisherProvider | SubscriberProvider;
 export interface MessageContext {
-    firstSent?: Date;
-    lastSent?: Date;
-    retries?: number;
+    firstSent: Date | undefined;
+    lastSent: Date | undefined;
+    attemptsMade: number | undefined;
+    willRetryOnFailure: boolean;
 }

package/dist/rabbitmq/config.d.ts

@@ -84,8 +84,10 @@ export interface RabbitQueueExchangeCustomConfiguration {
     retryQueueExchangeName?: string;
 }
 export interface RabbitMqMessageContext extends MessageContext {
-    exchangeName?: string;
-    routingKey?: string;
+    queueName: string;
+    exchangeName: string;
+    routingKey: string;
+    retryExchangeName: string;
 }
 /**
  * Returns the queue name based on the configuration

package/dist/rabbitmq/subscriber.d.ts

@@ -25,7 +25,7 @@ export declare class RabbitMqSubscriber implements SubscriberProvider {
     startSubscribe(config: RabbitQueueExchangeConfiguration, onMessage: (s: string, context: RabbitMqMessageContext) => Promise<MessageResult> | MessageResult): StopSubscribe;
     close(): Promise<void>;
     enrichHandledMesssageLog(config: RabbitQueueExchangeConfiguration): Record<string, unknown>;
-    static getRetries(msg: ConsumeMessage): number;
+    static getAttemptsMade(msg: ConsumeMessage): number;
     static getSentDates(msg: ConsumeMessage): {
         firstSent: Date | undefined;
         lastSent: Date | undefined;

package/dist/rabbitmq/subscriber.js

@@ -52,7 +52,7 @@ class SubscribedMessage {
     }
 }
 const RETRIES_HEADER = "x-retries";
-const RETRYSENT_HEADER = "x-retry-sent";
+const RETRY_SENT_HEADER = "x-retry-sent";
 class RabbitMqSubscriber {
     constructor(connection, logger) {
         this.connection = connection;
@@ -94,9 +94,10 @@ class RabbitMqSubscriber {
     enrichHandledMesssageLog(config) {
         return {
             queueName: (0, config_js_1.getQueueName)(config),
+            exchangeName: (0, config_js_1.getExchangeName)(config),
         };
     }
-    static getRetries(msg) {
+    static getAttemptsMade(msg) {
         var _a;
         return typeof ((_a = msg.properties.headers) === null || _a === void 0 ? void 0 : _a[RETRIES_HEADER]) === "number"
             ? msg.properties.headers[RETRIES_HEADER]
@@ -109,8 +110,8 @@ class RabbitMqSubscriber {
         const firstSent = typeof msg.properties.timestamp === "number"
             ? new Date(msg.properties.timestamp)
             : undefined;
-        const lastSent = typeof ((_a = msg.properties.headers) === null || _a === void 0 ? void 0 : _a[RETRYSENT_HEADER]) === "number"
-            ? new Date(msg.properties.headers[RETRYSENT_HEADER])
+        const lastSent = typeof ((_a = msg.properties.headers) === null || _a === void 0 ? void 0 : _a[RETRY_SENT_HEADER]) === "number"
+            ? new Date(msg.properties.headers[RETRY_SENT_HEADER])
             : firstSent;
         return { firstSent, lastSent };
     }
@@ -129,22 +130,39 @@ class RabbitMqSubscriber {
                 }, (span) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         subscribedMessage.busy++;
-                        yield this.consumeMessage(msg, channel, subscribedMessage, setupResult.retryExchangeName, retryDelay);
+                        yield this.consumeMessage({
+                            msg,
+                            channel,
+                            subscribedMessage,
+                            retryExchangeName: setupResult.retryExchangeName,
+                            retryDelay,
+                            queueName,
+                        });
                     }
                     catch (err) {
-                        this.logger.error({
+                        const logPayload = {
                             message: "Unexpected error handling RabbitMq message",
                             error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
-                        });
+                            extra: {
+                                queueName,
+                                message: msg.content.toString("utf8"),
+                            },
+                        };
+                        this.logger.error(logPayload);
                         span === null || span === void 0 ? void 0 : span.setTag("error", err);
                         try {
                             channel.nack(msg, undefined, true);
                         }
                         catch (err2) {
-                            this.logger.error({
+                            const logPayload2 = {
                                 message: "Unexpected error handling RabbitMq message during NACK attempt",
                                 error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err2),
-                            });
+                                extra: {
+                                    queueName,
+                                    message: msg.content.toString("utf8"),
+                                },
+                            };
+                            this.logger.error(logPayload2);
                         }
                     }
                     finally {
@@ -171,53 +189,68 @@ class RabbitMqSubscriber {
             });
         });
     }
-    consumeMessage(msg, channel, subscribedMessage, retryExchangeName, retryDelay) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+    consumeMessage(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ msg, channel, subscribedMessage, retryExchangeName, retryDelay, queueName, }) {
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
             const json = msg.content.toString("utf8");
-            const retries = RabbitMqSubscriber.getRetries(msg);
+            const attemptsMade = RabbitMqSubscriber.getAttemptsMade(msg);
             const sentDates = RabbitMqSubscriber.getSentDates(msg);
-            const context = Object.assign(Object.assign({ retries }, sentDates), { exchangeName: msg.fields.exchange, routingKey: msg.fields.routingKey });
+            const willRetryOnFailure = attemptsMade < ((_b = subscribedMessage.config.retries) !== null && _b !== void 0 ? _b : 0);
+            const context = Object.assign(Object.assign({ attemptsMade }, sentDates), { queueName, exchangeName: msg.fields.exchange, retryExchangeName, routingKey: msg.fields.routingKey, willRetryOnFailure });
             let messageResult;
+            let logPayload;
             try {
                 messageResult = yield subscribedMessage.onMessage(json, context);
+                logPayload = {
+                    message: `RabbitMq consumer handled message.`,
+                    extra: Object.assign({}, context),
+                };
             }
             catch (err) {
                 messageResult = interfaces_js_1.MessageResult.Retry;
-                this.logger.error({
-                    message: `RabbitMq consumer unhandled exception, retrying message to ${retryExchangeName} ${msg.fields.routingKey}`,
+                logPayload = {
+                    message: `RabbitMq consumer unhandled exception.`,
                     error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
-                });
+                    extra: Object.assign({}, context),
+                };
             }
             if (messageResult === interfaces_js_1.MessageResult.Ok) {
+                (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, logPayload);
                 channel.ack(msg);
                 return;
             }
-            if (messageResult === interfaces_js_1.MessageResult.Retry &&
-                subscribedMessage.config.retries &&
-                retries >= subscribedMessage.config.retries) {
-                messageResult = interfaces_js_1.MessageResult.Fail;
+            if (messageResult === interfaces_js_1.MessageResult.Retry) {
+                if (willRetryOnFailure) {
+                    logPayload.message += " Retrying message.";
+                }
+                else {
+                    messageResult = interfaces_js_1.MessageResult.Fail;
+                    logPayload.message += " No more retries.";
+                }
             }
             if (messageResult === interfaces_js_1.MessageResult.Fail) {
-                (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `RabbitMq retry count exceeded - sending message to DLQ`);
+                (_f = (_e = this.logger).debug) === null || _f === void 0 ? void 0 : _f.call(_e, logPayload);
                 channel.nack(msg, undefined, false);
                 return;
             }
-            const ok = yield ((_c = subscribedMessage.channel) === null || _c === void 0 ? void 0 : _c.publish(retryExchangeName, msg.fields.routingKey, msg.content, {
+            const ok = yield ((_g = subscribedMessage.channel) === null || _g === void 0 ? void 0 : _g.publish(retryExchangeName, msg.fields.routingKey, msg.content, {
                 contentType: msg.properties.contentType,
                 expiration: retryDelay,
-                timestamp: (_d = sentDates.firstSent) === null || _d === void 0 ? void 0 : _d.valueOf(),
+                timestamp: (_h = sentDates.firstSent) === null || _h === void 0 ? void 0 : _h.valueOf(),
                 headers: {
-                    [RETRIES_HEADER]: retries + 1,
-                    [RETRYSENT_HEADER]: Date.now(),
+                    [RETRIES_HEADER]: attemptsMade + 1,
+                    [RETRY_SENT_HEADER]: Date.now(),
                 },
             }));
             if (ok) {
-                (_f = (_e = this.logger).debug) === null || _f === void 0 ? void 0 : _f.call(_e, `RabbitMq retry queue success`);
+                (_k = (_j = this.logger).debug) === null || _k === void 0 ? void 0 : _k.call(_j, `RabbitMq retry queue success`);
+                (_m = (_l = this.logger).debug) === null || _m === void 0 ? void 0 : _m.call(_l, logPayload);
                 channel.ack(msg);
             }
             else {
-                (_h = (_g = this.logger).debug) === null || _h === void 0 ? void 0 : _h.call(_g, `RabbitMq retry queue failure - nack-ing message instead`);
+                (_p = (_o = this.logger).debug) === null || _p === void 0 ? void 0 : _p.call(_o, `RabbitMq retry queue failure - nack-ing message instead`);
+                logPayload.message += " Retry publish failed.";
+                this.logger.error(logPayload);
                 channel.nack(msg, undefined, true);
             }
         });

package/dist/subscriber.js

@@ -55,18 +55,20 @@ class Subscriber {
             if (!provider) {
                 throw new errors_js_1.MissingPubSubProviderError(`No provider configured for ${config.transport}`);
             }
-            const transform = (jsonStr, context) => __awaiter(this, void 0, void 0, function* () {
+            const enrichedConfig = provider.enrichHandledMesssageLog(config);
+            const handleMessage = (jsonStr, context) => __awaiter(this, void 0, void 0, function* () {
                 const start = (0, message_logger_js_1.startTiming)();
                 const jsonObject = JSON.parse(jsonStr);
-                const r = schema.safeDecode(jsonObject);
-                if (!r.success) {
+                const decodeResult = schema.safeDecode(jsonObject);
+                if (!decodeResult.success) {
                     const durationMs = (0, message_logger_js_1.getDuration)(start);
                     (0, message_logger_js_1.logMessage)({
                         note: "Subscribed message failed schema validation",
                         message: jsonObject,
                         level: "error",
                         logger: this.logger,
-                        extra: Object.assign({ transport: provider.transport, name: config.name, durationMs }, provider.enrichHandledMesssageLog(config)),
+                        extra: Object.assign({ transport: provider.transport, name: config.name, durationMs,
+                            context }, enrichedConfig),
                     });
                     const handledEventContext = {
                         message: jsonStr,
@@ -80,7 +82,7 @@ class Subscriber {
                     return interfaces_js_1.MessageResult.Fail;
                 }
                 try {
-                    const result = yield onMessage(r.data, context);
+                    const result = yield onMessage(decodeResult.data, context);
                     const durationMs = (0, message_logger_js_1.getDuration)(start);
                     const eventContext = {
                         message: jsonStr,
@@ -91,11 +93,12 @@ class Subscriber {
                     };
                     (0, message_logger_js_1.logMessage)({
                         note: "Subscriber processed message",
-                        message: r.data,
+                        message: decodeResult.data,
                         level: config.messageLogLevel,
                         logger: this.logger,
                         extra: Object.assign({ transport: provider.transport, name: config.name, durationMs,
-                            result }, provider.enrichHandledMesssageLog(config)),
+                            result,
+                            context }, enrichedConfig),
                     });
                     this.events.emit("messageHandled", eventContext);
                     return result;
@@ -104,24 +107,31 @@ class Subscriber {
                     const durationMs = (0, message_logger_js_1.getDuration)(start);
                     (0, message_logger_js_1.logMessage)({
                         note: "Subscriber error when processing message",
-                        message: r.data,
-                        level: "error",
+                        message: decodeResult.data,
+                        level: context.willRetryOnFailure ? "warn" : "error",
                         logger: this.logger,
-                        extra: Object.assign(Object.assign({ transport: provider.transport, name: config.name, durationMs }, provider.enrichHandledMesssageLog(config)), { error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err) }),
+                        extra: Object.assign(Object.assign({ transport: provider.transport, name: config.name, durationMs,
+                            context }, enrichedConfig), { error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err) }),
                     });
+                    // in the messageHandled event, we always log as retry or fail based on willRetryOnFailure
+                    const result = context.willRetryOnFailure
+                        ? interfaces_js_1.MessageResult.Retry
+                        : interfaces_js_1.MessageResult.Fail;
                     const eventContext = {
                         message: jsonStr,
+                        result,
                         context,
                         config,
                         durationMs,
                         err,
                     };
                     this.events.emit("messageHandled", eventContext);
-                    throw err;
+                    // but, always return Retry on exception to allow for retry logic to work in the providers
+                    return interfaces_js_1.MessageResult.Retry;
                 }
             });
             this.logger.log(`Starting subscriber for ${config.transport}:${config.name}`);
-            subscribedMessage = new SubscribedMessage(yield provider.startSubscribe(config, transform));
+            subscribedMessage = new SubscribedMessage(yield provider.startSubscribe(config, handleMessage));
             this.subscribedMessages.set(config, subscribedMessage);
             this.logger.log(`Started subscriber for ${config.transport}:${config.name}`);
             return () => __awaiter(this, void 0, void 0, function* () {

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@palmetto/pubsub",
-  "version": "3.0.2",
+  "version": "3.1.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/palmetto/galaxy"
+  },
   "main": "./dist/main.js",
   "scripts": {
     "lint": "yarn run -T eslint --fix ./src",