@palmetto/pubsub 3.1.0 → 3.2.1

package/dist/bullmq/subscriber.js

@@ -75,7 +75,7 @@ class BullMqSubscriber {
                         attemptsMade: job.attemptsMade,
                         firstSent: new Date(job.timestamp),
                         lastSent: undefined,
-                        willRetryOnFailure: this.willRetryJobOnFailure(job),
+                        willAttemptRetry: this.willRetryJobOnFailure(job),
                     };
                     const result = yield onMessage(job.data, context);
                     if (result === interfaces_js_1.MessageResult.Ok) {

package/dist/gcppubsub/config.d.ts

@@ -0,0 +1,66 @@
+import { type CreateSubscriptionOptions, type SubscriptionOptions, type PubSub, Topic } from "@google-cloud/pubsub";
+import { MessageContext, PubSubConfiguration } from "../interfaces.js";
+import { GCP_PUBSUB_TRANSPORT } from "./connection.js";
+export interface GcpPubSubConfiguration extends PubSubConfiguration {
+    /**
+     * Transport is always GCP_PUBSUB_TRANSPORT
+     */
+    transport: typeof GCP_PUBSUB_TRANSPORT;
+    /**
+     * The Pub/Sub topic name. Defaults to `name` if omitted.
+     */
+    topicName?: string;
+    /**
+     * The Pub/Sub dead-letter topic name. Defaults to `${name}.dl` if omitted.
+     */
+    deadLetterTopicName?: string;
+    /**
+     * The Pub/Sub subscription name. Required for subscribers. Defaults to `name` if omitted.
+     */
+    subscriptionName?: string;
+    /**
+     * Flow control: max outstanding messages (default: 5)
+     */
+    maxMessages?: number;
+    /**
+     * Maximum number of times to retry a message.
+     * Default: 0, no retries
+     * Max: 99 retries, see max_delivery_attempts in GCP docs
+     * Infinite retries: -1
+     */
+    retries?: number;
+    /**
+     * Maximum amount of time to wait, in milliseconds, before retrying a message. Default: 600_000 (10 minutes)
+     */
+    maxRetryDelay?: number;
+    /**
+     * Subscription settings to override defaults when creating a new subscription
+     */
+    createSubscriptionOptions?: CreateSubscriptionOptions;
+    /**
+     * subscription options to override defaults when starting a new subscription
+     */
+    subscriptionOptions?: SubscriptionOptions;
+    /**
+     * During shutdown, pending acks will be waited for up to this amount of time (in milliseconds) after the last message is received before the subscription is closed. Default: 1_000 (1 second)
+     */
+    shutdownDelay?: number;
+}
+export declare const RETRY_FOREVER = -1;
+export type TopicType = "default" | "dead-letter";
+export declare const TopicNameExtensions: Record<TopicType, string | undefined>;
+export interface GcpPubSubMessageContext extends MessageContext {
+    messageId: string;
+    subscriptionName: string;
+    topicName: string;
+    orderingKey?: string;
+}
+export declare function getTopicName(config: GcpPubSubConfiguration, topicType: TopicType): string;
+export declare function getSubscriptionName(config: GcpPubSubConfiguration): string;
+export declare function isGcpPubSubConfiguration(config: PubSubConfiguration): config is GcpPubSubConfiguration;
+export declare function ensureTopic(client: PubSub, topicName: string): Promise<void>;
+export declare function ensureSubscription(client: PubSub, config: GcpPubSubConfiguration): Promise<{
+    deadLetterTopic?: Topic;
+    retries: number;
+    created: boolean;
+}>;

package/dist/gcppubsub/config.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicNameExtensions = exports.RETRY_FOREVER = void 0;
+exports.getTopicName = getTopicName;
+exports.getSubscriptionName = getSubscriptionName;
+exports.isGcpPubSubConfiguration = isGcpPubSubConfiguration;
+exports.ensureTopic = ensureTopic;
+exports.ensureSubscription = ensureSubscription;
+const pubsub_1 = require("@google-cloud/pubsub");
+const connection_js_1 = require("./connection.js");
+exports.RETRY_FOREVER = -1;
+exports.TopicNameExtensions = {
+    "dead-letter": ".dl",
+    default: undefined,
+};
+function getTopicName(config, topicType) {
+    var _a, _b;
+    if (topicType === "dead-letter" && config.deadLetterTopicName) {
+        return config.deadLetterTopicName;
+    }
+    const baseName = (_a = config.topicName) !== null && _a !== void 0 ? _a : config.name;
+    const extension = (_b = exports.TopicNameExtensions[topicType]) !== null && _b !== void 0 ? _b : "";
+    return `${baseName}${extension}`;
+}
+function getSubscriptionName(config) {
+    var _a;
+    return (_a = config.subscriptionName) !== null && _a !== void 0 ? _a : getTopicName(config, "default");
+}
+function isGcpPubSubConfiguration(config) {
+    return config.transport === connection_js_1.GCP_PUBSUB_TRANSPORT;
+}
+function ensureTopic(client, topicName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const topics = (yield client.getTopics())[0];
+        if (!topics.some((t) => t.name.endsWith(`/${topicName}`))) {
+            yield client.createTopic(topicName);
+        }
+    });
+}
+function ensureSubscription(client, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const topic = client.topic(getTopicName(config, "default"));
+        const subscriptions = (yield topic.getSubscriptions({
+            pageSize: 1000,
+        }))[0];
+        const subscriptionName = getSubscriptionName(config);
+        const subscription = subscriptions.find((s) => s.name.endsWith(`/${subscriptionName}`));
+        if (subscription) {
+            const meta = (_a = subscription.metadata) !== null && _a !== void 0 ? _a : (yield subscription.getMetadata())[0];
+            let deadLetterTopic = undefined;
+            let retries;
+            if ((_b = meta.deadLetterPolicy) === null || _b === void 0 ? void 0 : _b.deadLetterTopic) {
+                const dlp = pubsub_1.protos.google.pubsub.v1.DeadLetterPolicy.create(meta.deadLetterPolicy);
+                if (config.retries !== undefined && config.retries < 0) {
+                    // If retries is negative, we want to retry forever, but GCP Pub/Sub doesn't support that, so we set it to the max allowed by the dead-letter policy
+                    retries = dlp.maxDeliveryAttempts - 1;
+                }
+                else {
+                    // config.retries can override maxDeliveryAttempts, but it can't exceed the max allowed by the dead-letter policy
+                    retries = Math.min((_c = config.retries) !== null && _c !== void 0 ? _c : 0, dlp.maxDeliveryAttempts - 1);
+                }
+                deadLetterTopic = client.topic(dlp.deadLetterTopic);
+            }
+            else {
+                retries = exports.RETRY_FOREVER;
+            }
+            return {
+                deadLetterTopic,
+                retries,
+                created: false,
+            };
+        }
+        const topicName = getTopicName(config, "default");
+        const dlTopicName = getTopicName(config, "dead-letter");
+        const minRetryDelay = (_d = config.retryDelay) !== null && _d !== void 0 ? _d : 30000;
+        const maxRetryDelay = config.maxRetryDelay;
+        const maxDeliveryAttempts = ((_e = config.retries) !== null && _e !== void 0 ? _e : 0) + 1;
+        const enableDeadLetter = maxDeliveryAttempts > 0;
+        if (enableDeadLetter) {
+            yield ensureSubscription(client, Object.assign(Object.assign({}, config), { retries: exports.RETRY_FOREVER, name: dlTopicName, topicName: dlTopicName, deadLetterTopicName: undefined, subscriptionName: `${dlTopicName}.sub`, retryDelay: minRetryDelay, maxRetryDelay }));
+        }
+        yield ensureTopic(client, topicName);
+        const enableRetryPolicy = minRetryDelay > 0 || maxRetryDelay !== undefined;
+        const deadLetterTopic = enableDeadLetter
+            ? client.topic(dlTopicName)
+            : undefined;
+        const options = Object.assign(Object.assign(Object.assign({}, (enableDeadLetter
+            ? {
+                deadLetterPolicy: {
+                    deadLetterTopic: deadLetterTopic === null || deadLetterTopic === void 0 ? void 0 : deadLetterTopic.name,
+                    maxDeliveryAttempts: Math.max(maxDeliveryAttempts, 5),
+                },
+            }
+            : {})), (enableRetryPolicy
+            ? {
+                retryPolicy: Object.assign({ minimumBackoff: {
+                        nanos: (minRetryDelay % 1000) * 1000000,
+                        seconds: Math.floor(minRetryDelay / 1000),
+                    } }, (maxRetryDelay !== undefined
+                    ? {
+                        maximumBackoff: {
+                            nanos: (maxRetryDelay % 1000) * 1000000,
+                            seconds: Math.floor(maxRetryDelay / 1000),
+                        },
+                    }
+                    : {})),
+            }
+            : {})), config.createSubscriptionOptions);
+        yield topic.createSubscription(subscriptionName, options);
+        return {
+            deadLetterTopic,
+            retries: maxDeliveryAttempts > 0 ? maxDeliveryAttempts - 1 : exports.RETRY_FOREVER,
+            created: true,
+        };
+    });
+}

package/dist/gcppubsub/connection.d.ts

@@ -0,0 +1,14 @@
+import type * as gcppubsub from "@google-cloud/pubsub";
+import { Logger } from "../interfaces.js";
+export declare const GCP_PUBSUB_TRANSPORT = "gcp-pubsub";
+export interface GcpPubSubConnectionConfig {
+    projectId?: string;
+    clientConfig?: gcppubsub.ClientConfig;
+}
+export declare class GcpPubSubConnection {
+    readonly client: gcppubsub.PubSub;
+    private readonly logger;
+    static create(config: GcpPubSubConnectionConfig, logger: Logger): Promise<GcpPubSubConnection>;
+    private constructor();
+    close(): Promise<void>;
+}

package/dist/gcppubsub/connection.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcpPubSubConnection = exports.GCP_PUBSUB_TRANSPORT = void 0;
+const lazy_load_js_1 = require("../lazy-load.js");
+exports.GCP_PUBSUB_TRANSPORT = "gcp-pubsub";
+class GcpPubSubConnection {
+    static create(config, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const GcpPubSubPackage = yield (0, lazy_load_js_1.lazyLoad)({
+                packageName: "@google-cloud/pubsub",
+                context: "GcpPubSubConnection",
+            });
+            const client = new GcpPubSubPackage.PubSub(Object.assign({ projectId: config.projectId }, config.clientConfig));
+            return new GcpPubSubConnection(client, logger);
+        });
+    }
+    constructor(client, logger) {
+        this.client = client;
+        this.logger = logger;
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, "GCP Pub/Sub closing connection");
+            yield this.client.close();
+        });
+    }
+}
+exports.GcpPubSubConnection = GcpPubSubConnection;

package/dist/gcppubsub/main.d.ts

@@ -0,0 +1,5 @@
+export * from "./config.js";
+export * from "./connection.js";
+export * from "./publisher.js";
+export * from "./subscriber.js";
+export * from "./pubsub.js";

package/dist/gcppubsub/main.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./connection.js"), exports);
+__exportStar(require("./publisher.js"), exports);
+__exportStar(require("./subscriber.js"), exports);
+__exportStar(require("./pubsub.js"), exports);

package/dist/gcppubsub/publisher.d.ts

@@ -0,0 +1,14 @@
+import { Logger, PublisherProvider, PublishMessageOptions } from "../interfaces.js";
+import { GcpPubSubConnection } from "./connection.js";
+import { GcpPubSubConfiguration } from "./config.js";
+export declare class GcpPubSubPublisher implements PublisherProvider {
+    private readonly connection;
+    private readonly logger;
+    private readonly topics;
+    constructor(connection: GcpPubSubConnection, logger: Logger);
+    readonly transport: string;
+    init(config: GcpPubSubConfiguration): Promise<void>;
+    publish(config: GcpPubSubConfiguration, messages: string[], options?: PublishMessageOptions): Promise<void>;
+    enrichPublishedMesssageLog(config: GcpPubSubConfiguration): Record<string, unknown>;
+    close(): void;
+}

package/dist/gcppubsub/publisher.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcpPubSubPublisher = void 0;
+const errors_js_1 = require("../errors.js");
+const connection_js_1 = require("./connection.js");
+const config_js_1 = require("./config.js");
+class GcpPubSubPublisher {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.topics = new Map();
+        this.transport = connection_js_1.GCP_PUBSUB_TRANSPORT;
+    }
+    init(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const topicName = (0, config_js_1.getTopicName)(config, "default");
+            yield (0, config_js_1.ensureTopic)(this.connection.client, topicName);
+            const topic = this.connection.client.topic(topicName);
+            this.topics.set(topicName, topic);
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `GCP Pub/Sub publisher initialized for topic ${topicName}`);
+        });
+    }
+    publish(config, messages, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options === null || options === void 0 ? void 0 : options.scheduledAt) {
+                throw new errors_js_1.PublishError("Scheduled publishing is not supported for GCP Pub/Sub", messages);
+            }
+            const topicName = (0, config_js_1.getTopicName)(config, "default");
+            let topic = this.topics.get(topicName);
+            if (!topic) {
+                topic = this.connection.client.topic(topicName);
+                this.topics.set(topicName, topic);
+            }
+            const oks = yield Promise.allSettled(messages.map((message) => topic.publishMessage({
+                data: Buffer.from(message, "utf8"),
+            })));
+            const failedMessages = oks
+                .map((ok, index) => ({ ok, index }))
+                .filter(({ ok }) => ok.status === "rejected")
+                .map(({ index }) => messages[index]);
+            if (failedMessages.length > 0) {
+                const allOrSome = failedMessages.length === messages.length ? "all" : "some";
+                throw new errors_js_1.PublishError(`GCP Pub/Sub publish to topic ${topicName} failed for ${allOrSome} messages`, failedMessages);
+            }
+        });
+    }
+    enrichPublishedMesssageLog(config) {
+        return {
+            topicName: (0, config_js_1.getTopicName)(config, "default"),
+        };
+    }
+    close() {
+        this.topics.clear();
+    }
+}
+exports.GcpPubSubPublisher = GcpPubSubPublisher;

package/dist/gcppubsub/pubsub.d.ts

@@ -0,0 +1,18 @@
+import { Logger, MessageContext, MessageResult, PublishMessageOptions, PubSubProvider, StopSubscribe } from "../interfaces.js";
+import { GcpPubSubConfiguration } from "./config.js";
+import { GcpPubSubConnection } from "./connection.js";
+/**
+ * Combines a GcpPubSubPublisher and GcpPubSubSubscriber into a single instance
+ */
+export declare class GcpPubSubProvider implements PubSubProvider {
+    private readonly publisher;
+    private readonly subscriber;
+    constructor(connection: GcpPubSubConnection, logger: Logger);
+    readonly transport: string;
+    publish(config: GcpPubSubConfiguration, messages: string[], options?: PublishMessageOptions): Promise<void>;
+    startSubscribe(config: GcpPubSubConfiguration, onMessage: (s: string, context: MessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe>;
+    close(): Promise<void>;
+    init(config: GcpPubSubConfiguration): Promise<void>;
+    enrichPublishedMesssageLog(config: GcpPubSubConfiguration): Record<string, unknown>;
+    enrichHandledMesssageLog(config: GcpPubSubConfiguration): Record<string, unknown>;
+}

package/dist/gcppubsub/pubsub.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcpPubSubProvider = void 0;
+const connection_js_1 = require("./connection.js");
+const publisher_js_1 = require("./publisher.js");
+const subscriber_js_1 = require("./subscriber.js");
+/**
+ * Combines a GcpPubSubPublisher and GcpPubSubSubscriber into a single instance
+ */
+class GcpPubSubProvider {
+    constructor(connection, logger) {
+        this.transport = connection_js_1.GCP_PUBSUB_TRANSPORT;
+        this.publisher = new publisher_js_1.GcpPubSubPublisher(connection, logger);
+        this.subscriber = new subscriber_js_1.GcpPubSubSubscriber(connection, logger);
+    }
+    publish(config, messages, options) {
+        return this.publisher.publish(config, messages, options);
+    }
+    startSubscribe(config, onMessage) {
+        return this.subscriber.startSubscribe(config, onMessage);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.subscriber.close();
+            this.publisher.close();
+        });
+    }
+    init(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.publisher.init(config);
+        });
+    }
+    enrichPublishedMesssageLog(config) {
+        return this.publisher.enrichPublishedMesssageLog(config);
+    }
+    enrichHandledMesssageLog(config) {
+        return this.subscriber.enrichHandledMesssageLog(config);
+    }
+}
+exports.GcpPubSubProvider = GcpPubSubProvider;

package/dist/gcppubsub/subscriber.d.ts

@@ -0,0 +1,19 @@
+import { Logger, MessageResult, StopSubscribe, SubscriberProvider } from "../interfaces.js";
+import { GcpPubSubConfiguration, GcpPubSubMessageContext } from "./config.js";
+import { GcpPubSubConnection } from "./connection.js";
+export declare class GcpPubSubSubscriber implements SubscriberProvider {
+    private readonly connection;
+    private readonly logger;
+    private readonly subscriptions;
+    private lastMessageDate;
+    constructor(connection: GcpPubSubConnection, logger: Logger);
+    readonly transport: string;
+    startSubscribe(config: GcpPubSubConfiguration, onMessage: (s: string, context: GcpPubSubMessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe>;
+    close(): Promise<void>;
+    enrichHandledMesssageLog(config: GcpPubSubConfiguration): Record<string, unknown>;
+    private consumeMessage;
+    /**
+     * Wait for in-flight message handling to complete before shutting down
+     */
+    private waitForMessagesToComplete;
+}

package/dist/gcppubsub/subscriber.js

@@ -0,0 +1,215 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcpPubSubSubscriber = void 0;
+const pubsub_1 = require("@google-cloud/pubsub");
+const trace_1 = require("@palmetto/trace");
+const interfaces_js_1 = require("../interfaces.js");
+const errors_js_1 = require("../errors.js");
+const create_log_error_payload_js_1 = require("../create-log-error-payload.js");
+const config_js_1 = require("./config.js");
+const connection_js_1 = require("./connection.js");
+const subscriber_js_1 = require("@google-cloud/pubsub/build/src/subscriber.js");
+const SHUTDOWN_DELAY = 1000;
+class GcpPubSubSubscriber {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.subscriptions = new Map();
+        this.lastMessageDate = 0;
+        this.transport = connection_js_1.GCP_PUBSUB_TRANSPORT;
+    }
+    startSubscribe(config, onMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const subscriptionName = (0, config_js_1.getSubscriptionName)(config);
+            if (this.subscriptions.has(subscriptionName)) {
+                throw new errors_js_1.AlreadySubscribingError(subscriptionName);
+            }
+            const topicName = (0, config_js_1.getTopicName)(config, "default");
+            const { deadLetterTopic, retries } = yield (0, config_js_1.ensureSubscription)(this.connection.client, config);
+            if (retries !== ((_a = config.retries) !== null && _a !== void 0 ? _a : 0)) {
+                const configRetries = (_b = config.retries) !== null && _b !== void 0 ? _b : 0;
+                const log = {
+                    message: `GCP Pub/Sub subscription ${subscriptionName} retry configuration mismatch.`,
+                    extra: {
+                        subscriptionName,
+                        configRetries,
+                        subscriptionRetries: retries,
+                    },
+                };
+                this.logger.warn(log);
+            }
+            const subscription = this.connection.client.subscription(subscriptionName, Object.assign({ flowControl: {
+                    maxMessages: (_c = config.maxMessages) !== null && _c !== void 0 ? _c : 5,
+                }, closeOptions: {
+                    behavior: subscriber_js_1.SubscriberCloseBehaviors.WaitForProcessing,
+                    timeout: pubsub_1.Duration.from({
+                        milliseconds: (_d = config.shutdownDelay) !== null && _d !== void 0 ? _d : SHUTDOWN_DELAY,
+                    }),
+                } }, config.subscriptionOptions));
+            const messageHandler = (message) => {
+                void this.consumeMessage({
+                    config,
+                    message,
+                    onMessage,
+                    subscriptionName,
+                    topicName,
+                    deadLetterTopic,
+                    retries,
+                });
+            };
+            const errorHandler = (err) => {
+                const log = {
+                    message: `GCP Pub/Sub subscriber error for ${subscriptionName}`,
+                    error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
+                };
+                this.logger.error(log);
+            };
+            subscription.on("message", messageHandler);
+            subscription.on("error", errorHandler);
+            this.subscriptions.set(subscriptionName, { subscription, config });
+            this.logger.log(`GCP Pub/Sub consumer started for ${subscriptionName}`);
+            return () => __awaiter(this, void 0, void 0, function* () {
+                subscription.removeListener("message", messageHandler);
+                subscription.removeListener("error", errorHandler);
+                yield this.waitForMessagesToComplete(config.shutdownDelay);
+                yield subscription.close();
+                this.subscriptions.delete(subscriptionName);
+                this.logger.log(`GCP Pub/Sub consumer stopped for ${subscriptionName}`);
+            });
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([...this.subscriptions.entries()].map((_a) => __awaiter(this, [_a], void 0, function* ([subscriptionName, sub]) {
+                yield this.waitForMessagesToComplete(sub.config.shutdownDelay);
+                yield sub.subscription.close();
+                this.logger.log(`GCP Pub/Sub consumer stopped for ${subscriptionName}`);
+            })));
+            this.subscriptions.clear();
+        });
+    }
+    enrichHandledMesssageLog(config) {
+        return {
+            subscriptionName: (0, config_js_1.getSubscriptionName)(config),
+            topicName: (0, config_js_1.getTopicName)(config, "default"),
+        };
+    }
+    consumeMessage(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ config, message, onMessage, subscriptionName, topicName, deadLetterTopic, retries, }) {
+            yield (0, trace_1.getTracer)().trace("pubsub.gcppubsub.consume", {
+                resource: `consume ${config.transport} ${subscriptionName}`,
+            }, (span) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f;
+                try {
+                    const firstPublished = message.publishTime;
+                    let retryCount = message.deliveryAttempt - 1;
+                    let willAttemptRetry;
+                    if (retryCount < 0 || retries === config_js_1.RETRY_FOREVER) {
+                        // in this case, we will retry forever
+                        retryCount = 0;
+                        willAttemptRetry = true;
+                    }
+                    else {
+                        willAttemptRetry = retryCount < retries;
+                    }
+                    const context = {
+                        attemptsMade: retryCount,
+                        firstSent: firstPublished,
+                        lastSent: undefined,
+                        willAttemptRetry,
+                        messageId: message.id,
+                        subscriptionName,
+                        topicName,
+                        orderingKey: message.orderingKey,
+                    };
+                    let messageResult;
+                    let logPayload;
+                    try {
+                        messageResult = yield onMessage(message.data.toString("utf8"), context);
+                        logPayload = {
+                            message: `GCP Pub/Sub consumer handled message.`,
+                            extra: Object.assign({}, context),
+                        };
+                    }
+                    catch (err) {
+                        messageResult = interfaces_js_1.MessageResult.Retry;
+                        logPayload = {
+                            message: `GCP Pub/Sub consumer unhandled exception.`,
+                            error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
+                            extra: Object.assign({}, context),
+                        };
+                    }
+                    this.lastMessageDate = Date.now();
+                    if (messageResult === interfaces_js_1.MessageResult.Ok) {
+                        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, logPayload);
+                        message.ack();
+                        return;
+                    }
+                    if (messageResult === interfaces_js_1.MessageResult.Retry && willAttemptRetry) {
+                        message.nack();
+                        logPayload.message += " Retrying message via gcp-pubsub.";
+                        (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, logPayload);
+                        return;
+                    }
+                    // Fail: either explicit Fail or Retry with no retries remaining
+                    if (messageResult === interfaces_js_1.MessageResult.Retry) {
+                        logPayload.message += " No more retries.";
+                    }
+                    (_f = (_e = this.logger).debug) === null || _f === void 0 ? void 0 : _f.call(_e, logPayload);
+                    if (deadLetterTopic &&
+                        (messageResult === interfaces_js_1.MessageResult.Fail || retryCount < 4)) {
+                        // Send all failed messages to the dead-letter topic
+                        // GCP Pub/Sub doesn't allow maxDeliveryAttempts less than 5, so we need to manually publish to the dead-letter topic for the first 4 retries
+                        logPayload.message += " Publishing message to dead-letter topic.";
+                        yield deadLetterTopic.publishMessage({
+                            data: message.data,
+                        });
+                        message.ack(); // ack the message to remove it from the subscription
+                    }
+                    else if (messageResult === interfaces_js_1.MessageResult.Fail) {
+                        message.ack(); // ack the message to remove it from the subscription
+                    }
+                    else {
+                        message.nack(); // nack the message to let pubsub send it to the DLQ
+                    }
+                }
+                catch (err) {
+                    const logPayload = {
+                        message: "Unexpected error handling GCP Pub/Sub message",
+                        error: (0, create_log_error_payload_js_1.createLogErrorPayload)(err),
+                        extra: {
+                            subscriptionName,
+                            message: message.data.toString("utf8"),
+                        },
+                    };
+                    this.logger.error(logPayload);
+                    span === null || span === void 0 ? void 0 : span.setTag("error", err);
+                    message.nack();
+                }
+            }));
+        });
+    }
+    /**
+     * Wait for in-flight message handling to complete before shutting down
+     */
+    waitForMessagesToComplete() {
+        return __awaiter(this, arguments, void 0, function* (shutdownDelay = SHUTDOWN_DELAY) {
+            const waitUntil = this.lastMessageDate + shutdownDelay;
+            const waitDuration = waitUntil - Date.now();
+            if (waitDuration > 0) {
+                yield new Promise((resolve) => setTimeout(resolve, waitDuration));
+            }
+        });
+    }
+}
+exports.GcpPubSubSubscriber = GcpPubSubSubscriber;

package/dist/interfaces.d.ts

@@ -66,15 +66,17 @@ export interface PubSubConfiguration {
 }
 export declare enum MessageResult {
     /**
-     * the message was handled successfully or can otherwise be ignored
+     * The message was handled. The transport should not deliver this message again.
      */
     Ok = "ok",
     /**
-     * The message should be retried
+     * The message should be retried by the transport.
+     * Whether the message is retried immediately or after a delay depends on the transport and configuration.
+     * If the number of retries exceeds the configured limit for the transport, the message is considered failed.
      */
     Retry = "retry",
     /**
-     * The message failed and is either discarded or stored in a dead-letter queue
+     * The message failed and is either discarded or stored in a dead-letter queue, depending on the transport and configuration.
      */
     Fail = "fail"
 }
@@ -129,8 +131,23 @@ export type PubSubProvider = PublisherProvider & SubscriberProvider;
  */
 export type PubOrSubProvider = PubSubProvider | PublisherProvider | SubscriberProvider;
 export interface MessageContext {
+    /**
+     * When the message was first published.
+     */
     firstSent: Date | undefined;
+    /**
+     * When the message was last published. Not all transports provide this information.
+     */
     lastSent: Date | undefined;
+    /**
+     * The number of times the message has been attempted to be processed. This is 0 for the first attempt, 1 for the first retry, etc.
+     * Note that for some transports, this number is an approximation based on the number of times the message has been redelivered, or may always be 0.
+     */
     attemptsMade: number | undefined;
-    willRetryOnFailure: boolean;
+    /**
+     * If the onMessage callback returns MessageResult.Retry or throws an exception:
+     * When true, the message will be retried
+     * When false, the message will not be retried
+     */
+    willAttemptRetry: boolean;
 }

package/dist/interfaces.js

@@ -14,15 +14,17 @@ exports.IdMetaSchema = zod_1.z.object({
 var MessageResult;
 (function (MessageResult) {
     /**
-     * the message was handled successfully or can otherwise be ignored
+     * The message was handled. The transport should not deliver this message again.
      */
     MessageResult["Ok"] = "ok";
     /**
-     * The message should be retried
+     * The message should be retried by the transport.
+     * Whether the message is retried immediately or after a delay depends on the transport and configuration.
+     * If the number of retries exceeds the configured limit for the transport, the message is considered failed.
      */
     MessageResult["Retry"] = "retry";
     /**
-     * The message failed and is either discarded or stored in a dead-letter queue
+     * The message failed and is either discarded or stored in a dead-letter queue, depending on the transport and configuration.
      */
     MessageResult["Fail"] = "fail";
 })(MessageResult || (exports.MessageResult = MessageResult = {}));

package/dist/main.d.ts

@@ -4,3 +4,4 @@ export * from "./publisher.js";
 export * from "./subscriber.js";
 export * from "./bullmq/main.js";
 export * from "./rabbitmq/main.js";
+export * from "./gcppubsub/main.js";

package/dist/main.js

@@ -20,3 +20,4 @@ __exportStar(require("./publisher.js"), exports);
 __exportStar(require("./subscriber.js"), exports);
 __exportStar(require("./bullmq/main.js"), exports);
 __exportStar(require("./rabbitmq/main.js"), exports);
+__exportStar(require("./gcppubsub/main.js"), exports);

package/dist/message-logger.d.ts

@@ -1,6 +1,6 @@
 import { Logger, MessageLogLevel } from "./interfaces";
-export declare function startTiming(): [number, number];
-export declare function getDuration(start: [number, number]): number;
+export declare function startTiming(): bigint;
+export declare function getDuration(start: bigint): number;
 export declare function logMessage({ note, message, logger, level, extra, }: {
     note: string;
     message: unknown;

package/dist/message-logger.js

@@ -4,10 +4,10 @@ exports.startTiming = startTiming;
 exports.getDuration = getDuration;
 exports.logMessage = logMessage;
 function startTiming() {
-    return process.hrtime();
+    return process.hrtime.bigint();
 }
 function getDuration(start) {
-    return process.hrtime(start)[1] / 1000000; // convert to milliseconds
+    return Number(process.hrtime.bigint() - start) / 1000000; // convert to milliseconds
 }
 function logMessage({ note, message, logger, level = "debug", extra, }) {
     var _a;

package/dist/rabbitmq/subscriber.js

@@ -195,8 +195,8 @@ class RabbitMqSubscriber {
             const json = msg.content.toString("utf8");
             const attemptsMade = RabbitMqSubscriber.getAttemptsMade(msg);
             const sentDates = RabbitMqSubscriber.getSentDates(msg);
-            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 });
+            const willAttemptRetry = 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, willAttemptRetry });
             let messageResult;
             let logPayload;
             try {
@@ -220,7 +220,7 @@ class RabbitMqSubscriber {
                 return;
             }
             if (messageResult === interfaces_js_1.MessageResult.Retry) {
-                if (willRetryOnFailure) {
+                if (willAttemptRetry) {
                     logPayload.message += " Retrying message.";
                 }
                 else {

package/dist/subscriber.js

@@ -108,13 +108,13 @@ class Subscriber {
                     (0, message_logger_js_1.logMessage)({
                         note: "Subscriber error when processing message",
                         message: decodeResult.data,
-                        level: context.willRetryOnFailure ? "warn" : "error",
+                        level: context.willAttemptRetry ? "warn" : "error",
                         logger: this.logger,
                         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
+                    // in the messageHandled event, we always log as retry or fail based on willAttemptRetry
+                    const result = context.willAttemptRetry
                         ? interfaces_js_1.MessageResult.Retry
                         : interfaces_js_1.MessageResult.Fail;
                     const eventContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/pubsub",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/palmetto/galaxy"
@@ -24,6 +24,7 @@
     "test:watch": "yarn run test-runner vitest watch"
   },
   "devDependencies": {
+    "@google-cloud/pubsub": "^5.2.3",
     "@palmetto/trace": "^0.1.0",
     "@types/amqplib": "^0",
     "@types/node": "^24.2.1",
@@ -49,10 +50,11 @@
     "uuid": "^11.1.0"
   },
   "peerDependencies": {
+    "@google-cloud/pubsub": "^5.2",
     "@palmetto/trace": "^0.1.0",
     "amqp-connection-manager": "^4.1.14",
     "amqplib": "^0.10.8",
     "bullmq": "^5.58.0",
-    "zod": "^4.1.13"
+    "zod": "^4.1"
   }
 }

package/src/gcppubsub/README.md

@@ -0,0 +1,216 @@
+# @palmetto/pubsub
+
+The GoogleCloud Pub/Sub (gcp-pubsub) transport provider for @palmetto/pubsub
+
+## Installation
+
+```sh
+yarn add @palmetto/pubsub @google-cloud/pubsub zod
+```
+
+## Usage
+
+1. Define your connection string
+
+   ```ts
+   import { GcpPubSubConnectionConfig } from "@palmetto/pubsub";
+
+   const config: GcpPubSubConnectionConfig = {
+     projectId: "GOOGLE_PROJECT_ID",
+   };
+   ```
+
+2. Create the connection
+
+   ```ts
+   import { GcpPubSubConnection } from "@palmetto/pubsub";
+
+   const connection = await GcpPubSubConnection.create(config, console);
+   ```
+
+3. Create the publisher
+
+   ```ts
+   import { Publisher, GcpPubSubPublisher } from "@palmetto/pubsub";
+
+   const publisher = new Publisher(console, [
+     new GcpPubSubPublisher(connection, console),
+   ]);
+   ```
+
+4. Create the subscriber
+
+   ```ts
+   import { Subscriber, GcpPubSubSubscriber } from "@palmetto/pubsub";
+
+   const subscriber = new Subscriber(console, [
+     new GcpPubSubSubscriber(connection, console),
+   ]);
+   ```
+
+5. Create the topic/subscriber configuration
+
+   ```ts
+   import {
+     GcpPubSubConfiguration,
+     GCP_PUBSUB_TRANSPORT,
+   } from "@palmetto/pubsub";
+
+   import { z } from "zod";
+
+   const MyModelSchema = z.object({...});
+
+   const config: GcpPubSubConfiguration = {
+     name: "my-name",
+     topicName: "my-topic-name", // default: name
+     subscriptionName: "my-subscription-name", // default: topicName or name
+     schema: MyModelSchema,
+     transport: GCP_PUBSUB_TRANSPORT,
+     retries: 10, // Note: enables dead-letter policy. Use RETRY_FOREVER to disable dead-letter. @palmetto/pubsub will not update an existing subscription.
+     retryDelay: 1_000, // Note: retryDelay is minimum retry milliseconds using the exponential backoff retry policy. @palmetto/pubsub will not update an existing subscription.
+     createSubscriptionOptions: { ... }, // set the specific createSubscription() options you want to use [optional]
+     subscriptionOptions: { ... }, // set any specific subscribe() options you want to use [optional]
+   };
+   ```
+
+6. Initialize the publisher
+
+   For performance reasons, it's a good idea to initialize the publisher on your API startup. This can reduce the latency for the first message published.
+
+   ```ts
+   await publisher.init(config);
+   ```
+
+7. Publish a message
+
+   ```ts
+   const message: MyModel = {... };
+
+   await publisher.publish(config, message);
+   ```
+
+8. Subscribe to a topic
+
+   ```ts
+   import { GcpPubSubMessageContext } from "@palmetto/pubsub";
+
+   subscriber.addSubscriber(queue, (message: MyModel, context: GcpPubSubMessageContext) => {
+       ...
+       return MessageResult.Ok;
+   });
+   ```
+
+9. Subscribe to the dead-letter topic if you want to re-process completely failed messages. Pass the dead-letter topicName to the config.
+
+   ```ts
+   import { getTopicName } from "@palmetto/pubsub";
+
+   const dlConfig = {
+     ...config,
+     topicName: getTopicName(config, "dead-letter")
+   };
+
+   subscriber.addSubscriber(dlConfig, (message: MyModel, context: GcpPubSubMessageContext) => {
+      ...
+      return MessageResult.Ok; // returning Ok will remove the message from the dead-letter topic
+   });
+   ```
+
+## Message Handlers
+
+Message handlers can return one of 3 values:
+
+- `MessageResult.Ok` - the message can be removed from subscription. Messages are always `ack()`'ed.
+- `MessageResult.Retry` - the message can be retried, depending on the dead-letter/retry configuration. Messages are typically `nack()`'ed to use gcp-pubsub dead-letter policy. [See below](#retrying-messages)
+- `MessageResult.Fail` - Remove it from the subscription and publish it to the dead-letter topic (if available). Messages are always `ack()`'ed. [See below](#failing-messages)
+
+If a message handler throws an exception, this is the same as if it returned `MessageResult.Retry`.
+
+### Retrying messages
+
+By default gcp-pubsub subscriptions retry messages immediately, but `@palmetto/pubsub` subscriptions default to a 30 second retry policy.
+
+- minimum backoff: default 30 seconds
+- maximum backoff: default 10 minutes (gcp-pubsub default)
+
+You can adjust these defaults using these two configuration settings:
+
+- `retryDelay`
+  - 0 : immediate retry
+  - 1 to 600_000 : enable exponential backoff retry policy (values over 600_000 [10 minutes] are not supported by gcp-pubsub)
+- `maxRetryDelay`
+  - any value here enables exponential backoff retry policy
+  - be sure this value is equal to or larger than the `retryDelay`
+
+Messages can be retried when the handler throws an exception or when it returns `MessageResult.Retry`.
+
+The `retries` property configures the subscription retry policy when `@palmetto/pubsub` creates the subscription. If `@palmetto/pubsub` didn't create the subscription, whatever retry policy in place is what will be used (by default there are infinite retries).
+
+NOTE: If the subscription already exists, and there is no dead-letter policy, the configured `retries` value is ignored and assumes `RETRY_FOREVER` instead.
+
+The following special values define how `@palmetto/pubsub` creates the subscription retry policy:
+
+#### `{ retries: RETRY_FOREVER }`
+
+Use `RETRY_FOREVER` or `-1` to disable dead-letter policy.
+
+When a message handler throws an exception or returns `MessageResult.Retry` the message is retried. Messages are retried until the message retention period expires.
+
+When a message handler returns `MessageResult.Fail` or `MessageResult.Ok`, `ack()` is called on the message to remove it from the subscription.
+
+The `messageContext` includes `{ attemptsMade: 0 }` on every message.
+
+#### `{ retries: undefined }` or `{ retries: 0 }`
+
+There are no retries, but dead-letter topic is enabled.
+
+An exception or return values of `MessageResult.Fail` or `MessageResult.Retry` the message is published to the dead-letter topic and `ack()` is called on the message to remove it from the subscription.
+
+The `messageContext` includes `{ attemptsMade: 0 }` on the first message and will be a number greater than 0 if the message is retried due to the race condition.
+
+#### `{ retries: 1, 2 or 3 }`
+
+Dead-letter topic is enabled.
+
+An exception or return of `MessageResult.Retry` will `nack()` the message so it is retried by Google up to the specified retries.
+At that point, the message is published to the dead-letter topic and `ack()` is called on the message.
+
+A return of `MessageResult.Fail` will publish the message to the dead-letter topic and `ack()` is called on the message to remove it from the subscription.
+
+The `messageContext` includes `{ attemptsMade: 0-3 }` for each retry. It's possible to be attemptsMade up to 4 due to the race condition above.
+
+#### `{ retries: 4 to 99 }`
+
+Dead-letter topic is enabled.
+
+An exception or return of `MessageResult.Retry` will `nack()` the message so it is retried by Google up to the specified retries.
+
+A return of `MessageResult.Fail` will publish the message to the dead-letter topic and `ack()` is called on the message.
+
+The `messageContext` includes `{ attemptsMade: 0-99 }` for each retry.
+
+#### `{ retries: 100 or more }`
+
+These are not valid when creating a gcp-pubsub subscription. Creating a new subscription will fail.
+
+### Failing messages
+
+dead-letter topics are used when:
+
+- `retries` is undefined or greater than or equal to 0
+- or the subscription already has a dead-letter policy in place
+
+dead-letter topics are NOT used when:
+
+- `retries` is less than 0
+- the subscription already exists without a dead-letter policy in place
+
+If a dead-letter topic exists and the message handler returns `MessageResult.Fail` the message will be published to the dead-letter topic and `ack()` will be called on the message, removing it from the subscription.
+
+There is a possible race condition between publishing the dead-letter message and acknowledging the message causing the message to be re-delivered. This can result in the message ending up in the dead-letter topic more than once, or possibly a message in the dead-letter topic and also successfully handled. This race condition only occurs when `@palmetto/pubsub` is publishing to the dead-letter topic. It should not happen when using the gcp-pubsub dead-letter policy.
+
+Note: be sure the dead-letter topic is configured correctly. gcp-pubsub has some strict requirements on how to configure it.
+You can visit the subscription in the Google Cloud console and go to the "Dead lettering" tab to identify and fix any issues.
+The trickiest part might be setting the [IAM roles](https://docs.cloud.google.com/pubsub/docs/dead-letter-topics#grant_forwarding_permissions).
+
+Note: When `@palmetto/pubsub` creates the dead-letter topic, it also creates a default subscription ending in `.sub` to ensure dead-letter messages are not lost.

package/src/rabbitmq/README.md

@@ -13,6 +13,8 @@ yarn add @palmetto/pubsub amqp-connection-manager amqplib zod
 1. Define your connection string
 
    ```ts
+   import { RabbitMqConnectionConfig } from "@palmetto/pubsub";
+
    const config: RabbitMqConnectionConfig = {
      host: "amqp://guest:guest@localhost:5672/",
    };
@@ -21,20 +23,26 @@ yarn add @palmetto/pubsub amqp-connection-manager amqplib zod
 2. Create the connection
 
    ```ts
-   const connection = new RabbitMqConnection(config, console);
+   import { RabbitMqConnection } from "@palmetto/pubsub";
+
+   const connection = await RabbitMqConnection.create(config, console);
    ```
 
 3. Create the publisher
 
    ```ts
+   import { Publisher, RabbitMqPublisher } from "@palmetto/pubsub";
+
    const publisher = new Publisher(console, [
-     RabbitMqPublisher(connection, console),
+     new RabbitMqPublisher(connection, console),
    ]);
    ```
 
 4. Create the subscriber
 
    ```ts
+   import { Subscriber, RabbitMqSubscriber } from "@palmetto/pubsub";
+
    const subscriber = new Subscriber(console, [
      new RabbitMqSubscriber(connection, console),
    ]);
@@ -43,6 +51,11 @@ yarn add @palmetto/pubsub amqp-connection-manager amqplib zod
 5. Create the queue configuration
 
    ```ts
+   import { RabbitQueueExchangeConfiguration } from "@palmetto/pubsub";
+   import { z } from "zod";
+
+   const MyModelSchema = z.object({...});
+
    const queue: RabbitQueueExchangeConfiguration = {
      name: "my-queue-name",
      schema: MyModelSchema,
@@ -101,7 +114,7 @@ Message failures in RabbitMq subscribers are handled using special queues and ex
 
 These properties configure message retries:
 
-- `retries` : specifies the number of retries after which the message is discarded. When this value is undefined, the message will retry forever.
+- `retries` : specifies the number of retries after which the message is discarded. When this value is undefined, the message will not retry.
 - `retryDelay`: specifies the number of milliseconds between retries.
 
 #### The retry queue