jetstream_bridge 2.9.0 → 3.0.0

data/lib/generators/jetstream_bridge/initializer/templates/jetstream_bridge.rb

@@ -1,24 +1,72 @@
 # frozen_string_literal: true
 
-# Jetstream Bridge configuration
+# JetstreamBridge configuration
+# See https://github.com/your-org/jetstream_bridge for full documentation
+#
+# This initializer configures the JetStream Bridge gem for Rails applications.
+# The gem provides reliable, production-ready message passing between services
+# using NATS JetStream with support for outbox/inbox patterns, DLQ, and more.
 JetstreamBridge.configure do |config|
-  # NATS Connection
-  config.nats_urls       = ENV.fetch('NATS_URLS', 'nats://localhost:4222')
-  config.env             = ENV.fetch('NATS_ENV',  Rails.env)
-  config.app_name        = ENV.fetch('APP_NAME',  Rails.application.class.module_parent_name.underscore)
-  config.destination_app = ENV['DESTINATION_APP'] # required for cross-app data sync
+  # ============================================================================
+  # NATS Connection Settings
+  # ============================================================================
+  # NATS server URLs (comma-separated for cluster)
+  config.nats_urls = ENV.fetch('NATS_URLS', 'nats://localhost:4222')
 
-  # Consumer Tuning
+  # Environment identifier (e.g., 'development', 'production')
+  # Used in stream names and subject routing
+  config.env = ENV.fetch('NATS_ENV', Rails.env)
+
+  # Application name (used in subject routing)
+  config.app_name = ENV.fetch('APP_NAME', Rails.application.class.module_parent_name.underscore)
+
+  # Destination app for cross-app sync (REQUIRED for publishing/consuming)
+  config.destination_app = ENV.fetch('DESTINATION_APP', nil)
+
+  # ============================================================================
+  # Consumer Settings
+  # ============================================================================
+  # Maximum delivery attempts before moving message to DLQ
   config.max_deliver = 5
-  config.ack_wait    = '30s'
-  config.backoff     = %w[1s 5s 15s 30s 60s]
 
+  # How long to wait for message acknowledgment
+  config.ack_wait = '30s'
+
+  # Exponential backoff delays between retry attempts
+  config.backoff = %w[1s 5s 15s 30s 60s]
+
+  # ============================================================================
   # Reliability Features
+  # ============================================================================
+  # Enable transactional outbox pattern for guaranteed message delivery
   config.use_outbox = false
-  config.use_inbox  = false
-  config.use_dlq    = true
 
-  # Models (override if you keep custom AR classes)
+  # Enable inbox pattern for exactly-once processing (idempotency)
+  config.use_inbox = false
+
+  # Enable Dead Letter Queue for failed messages
+  config.use_dlq = true
+
+  # ============================================================================
+  # Active Record Models
+  # ============================================================================
+  # Override these if you've created custom model classes
   config.outbox_model = 'JetstreamBridge::OutboxEvent'
-  config.inbox_model  = 'JetstreamBridge::InboxEvent'
+  config.inbox_model = 'JetstreamBridge::InboxEvent'
+
+  # ============================================================================
+  # Logging
+  # ============================================================================
+  # Custom logger (defaults to Rails.logger if not set)
+  # config.logger = Rails.logger
 end
+
+# Validate configuration (optional but recommended for development)
+# Uncomment to enable validation on Rails boot
+# begin
+#   JetstreamBridge.config.validate!
+#   Rails.logger.info "[JetStream Bridge] Configuration validated successfully"
+# rescue JetstreamBridge::ConfigurationError => e
+#   Rails.logger.error "[JetStream Bridge] Configuration error: #{e.message}"
+#   raise if Rails.env.production?
+# end

data/lib/generators/jetstream_bridge/install/install_generator.rb

@@ -8,11 +8,13 @@ module JetstreamBridge
     class InstallGenerator < Rails::Generators::Base
       desc 'Creates JetstreamBridge initializer and migrations'
       def create_initializer
-        Rails::Generators.invoke('jetstream_bridge:initializer', [], behavior: behavior, destination_root: destination_root)
+        Rails::Generators.invoke('jetstream_bridge:initializer', [], behavior: behavior,
+                                                                     destination_root: destination_root)
       end
 
       def create_migrations
-        Rails::Generators.invoke('jetstream_bridge:migrations', [], behavior: behavior, destination_root: destination_root)
+        Rails::Generators.invoke('jetstream_bridge:migrations', [], behavior: behavior,
+                                                                    destination_root: destination_root)
       end
     end
   end

data/lib/generators/jetstream_bridge/migrations/migrations_generator.rb

@@ -8,6 +8,7 @@ module JetstreamBridge
     # Migrations generator.
     class MigrationsGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
+
       source_root File.expand_path('templates', __dir__)
       desc 'Creates Inbox/Outbox migrations for JetstreamBridge'
 

data/lib/jetstream_bridge/consumer/consumer.rb

@@ -7,7 +7,6 @@ require_relative '../core/duration'
 require_relative '../core/logging'
 require_relative '../core/config'
 require_relative '../core/model_utils'
-require_relative 'consumer_config'
 require_relative 'message_processor'
 require_relative 'subscription_manager'
 require_relative 'inbox/inbox_processor'
@@ -20,15 +19,15 @@ module JetstreamBridge
     IDLE_SLEEP_SECS       = 0.05
     MAX_IDLE_BACKOFF_SECS = 1.0
 
-    def initialize(durable_name: JetstreamBridge.config.durable_name,
-                   batch_size: DEFAULT_BATCH_SIZE, &block)
+    def initialize(durable_name: nil, batch_size: nil, &block)
       raise ArgumentError, 'handler block required' unless block_given?
 
       @handler       = block
-      @batch_size    = Integer(batch_size)
-      @durable       = durable_name
+      @batch_size    = Integer(batch_size || DEFAULT_BATCH_SIZE)
+      @durable       = durable_name || JetstreamBridge.config.durable_name
       @idle_backoff  = IDLE_SLEEP_SECS
       @running       = true
+      @shutdown_requested = false
       @jts           = Connection.connect!
 
       ensure_destination!
@@ -38,6 +37,7 @@ module JetstreamBridge
       @inbox_proc = InboxProcessor.new(@processor) if JetstreamBridge.config.use_inbox
 
       ensure_subscription!
+      setup_signal_handlers
     end
 
     def run!
@@ -49,11 +49,17 @@ module JetstreamBridge
         processed = process_batch
         idle_sleep(processed)
       end
+
+      # Drain in-flight messages before exiting
+      drain_inflight_messages if @shutdown_requested
+      Logging.info("Consumer #{@durable} stopped gracefully", tag: 'JetstreamBridge::Consumer')
     end
 
     # Allow external callers to stop a long-running loop gracefully.
     def stop!
+      @shutdown_requested = true
       @running = false
+      Logging.info("Consumer #{@durable} shutdown requested", tag: 'JetstreamBridge::Consumer')
     end
 
     private
@@ -103,15 +109,15 @@ module JetstreamBridge
       0
     end
 
-    def handle_js_error(e)
-      if recoverable_consumer_error?(e)
+    def handle_js_error(error)
+      if recoverable_consumer_error?(error)
         Logging.warn(
-          "Recovering subscription after error: #{e.class} #{e.message}",
+          "Recovering subscription after error: #{error.class} #{error.message}",
           tag: 'JetstreamBridge::Consumer'
         )
         ensure_subscription!
       else
-        Logging.error("Fetch failed (non-recoverable): #{e.class} #{e.message}", tag: 'JetstreamBridge::Consumer')
+        Logging.error("Fetch failed (non-recoverable): #{error.class} #{error.message}", tag: 'JetstreamBridge::Consumer')
       end
       0
     end
@@ -140,5 +146,40 @@ module JetstreamBridge
         @idle_backoff = IDLE_SLEEP_SECS
       end
     end
+
+    def setup_signal_handlers
+      %w[INT TERM].each do |sig|
+        Signal.trap(sig) do
+          Logging.info("Received #{sig}, stopping consumer...", tag: 'JetstreamBridge::Consumer')
+          stop!
+        end
+      end
+    rescue ArgumentError => e
+      # Signal handlers may not be available in all environments (e.g., threads)
+      Logging.debug("Could not set up signal handlers: #{e.message}", tag: 'JetstreamBridge::Consumer')
+    end
+
+    def drain_inflight_messages
+      return unless @psub
+
+      Logging.info("Draining in-flight messages...", tag: 'JetstreamBridge::Consumer')
+      # Process any pending messages with a short timeout
+      5.times do
+        begin
+          msgs = @psub.fetch(@batch_size, timeout: 1)
+          break if msgs.nil? || msgs.empty?
+
+          msgs.each { |m| process_one(m) }
+        rescue NATS::Timeout, NATS::IO::Timeout
+          break
+        rescue StandardError => e
+          Logging.warn("Error draining messages: #{e.class} #{e.message}", tag: 'JetstreamBridge::Consumer')
+          break
+        end
+      end
+      Logging.info("Drain complete", tag: 'JetstreamBridge::Consumer')
+    rescue StandardError => e
+      Logging.error("Drain failed: #{e.class} #{e.message}", tag: 'JetstreamBridge::Consumer')
+    end
   end
 end

data/lib/jetstream_bridge/consumer/dlq_publisher.rb

@@ -11,17 +11,20 @@ module JetstreamBridge
     end
 
     # Sends original payload to DLQ with explanatory headers/context
+    # @return [Boolean] true if published successfully, false otherwise
     def publish(msg, ctx, reason:, error_class:, error_message:)
-      return unless JetstreamBridge.config.use_dlq
+      return true unless JetstreamBridge.config.use_dlq
 
       envelope = build_envelope(ctx, reason, error_class, error_message)
       headers  = build_headers(msg.header, reason, ctx.deliveries, envelope)
       @jts.publish(JetstreamBridge.config.dlq_subject, msg.data, header: headers)
+      true
     rescue StandardError => e
       Logging.error(
         "DLQ publish failed event_id=#{ctx.event_id}: #{e.class} #{e.message}",
         tag: 'JetstreamBridge::Consumer'
       )
+      false
     end
 
     private

data/lib/jetstream_bridge/consumer/inbox/inbox_message.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require 'oj'
+require 'securerandom'
 
 module JetstreamBridge
   # Immutable value object for a single NATS message.
   class InboxMessage
     attr_reader :msg, :seq, :deliveries, :stream, :subject, :headers, :body, :raw, :event_id, :now
 
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def self.from_nats(msg)
       meta       = (msg.respond_to?(:metadata) && msg.metadata) || nil
       seq        = meta.respond_to?(:stream_sequence) ? meta.stream_sequence : nil
@@ -26,11 +28,14 @@ module JetstreamBridge
       end
 
       id = (headers['nats-msg-id'] || body['event_id']).to_s.strip
-      id = "seq:#{seq}" if id.empty?
+      id = "seq:#{seq}" if id.empty? && seq
+      id = SecureRandom.uuid if id.to_s.empty?
 
       new(msg, seq, deliveries, stream, subject, headers, body, raw, id, Time.now.utc, consumer)
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+    # rubocop:disable Metrics/ParameterLists
     def initialize(msg, seq, deliveries, stream, subject, headers, body, raw, event_id, now, consumer = nil)
       @msg        = msg
       @seq        = seq
@@ -44,6 +49,7 @@ module JetstreamBridge
       @now        = now
       @consumer   = consumer
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def body_for_store
       body.empty? ? raw : body
@@ -59,7 +65,7 @@ module JetstreamBridge
 
     def metadata
       @metadata ||= Struct.new(:num_delivered, :sequence, :consumer, :stream)
-                           .new(deliveries, seq, @consumer, stream)
+                          .new(deliveries, seq, @consumer, stream)
     end
 
     def ack(*args, **kwargs)

data/lib/jetstream_bridge/consumer/inbox/inbox_repository.rb

@@ -25,75 +25,51 @@ module JetstreamBridge
     end
 
     def persist_pre(record, msg)
-      ModelUtils.assign_known_attrs(record, {
-                                      event_id: (if ModelUtils.has_columns?(@klass,
-                                                                            :event_id)
-                                                   msg.event_id
-                                                 end),
-                                      subject: msg.subject,
-                                      payload: ModelUtils.json_dump(msg.body_for_store),
-                                      headers: ModelUtils.json_dump(msg.headers),
-                                      stream: (if ModelUtils.has_columns?(@klass,
-                                                                          :stream)
-                                                 msg.stream
-                                               end),
-                                      stream_seq: (if ModelUtils.has_columns?(@klass,
-                                                                              :stream_seq)
-                                                     msg.seq
-                                                   end),
-                                      deliveries: (if ModelUtils.has_columns?(@klass,
-                                                                              :deliveries)
-                                                     msg.deliveries
-                                                   end),
-                                      status: 'processing',
-                                      last_error: nil,
-                                      received_at: (if ModelUtils.has_columns?(@klass,
-                                                                               :received_at)
-                                                      record.received_at || msg.now
-                                                    end),
-                                      updated_at: (if ModelUtils.has_columns?(@klass,
-                                                                              :updated_at)
-                                                     msg.now
-                                                   end)
-                                    })
-      record.save!
+      ActiveRecord::Base.transaction do
+        attrs = {
+          event_id: msg.event_id,
+          subject: msg.subject,
+          payload: ModelUtils.json_dump(msg.body_for_store),
+          headers: ModelUtils.json_dump(msg.headers),
+          stream: msg.stream,
+          stream_seq: msg.seq,
+          deliveries: msg.deliveries,
+          status: 'processing',
+          last_error: nil,
+          received_at: record.respond_to?(:received_at) ? (record.received_at || msg.now) : nil,
+          updated_at: record.respond_to?(:updated_at) ? msg.now : nil
+        }
+        ModelUtils.assign_known_attrs(record, attrs)
+        record.save!
+      end
     end
 
     def persist_post(record)
-      now = Time.now.utc
-      ModelUtils.assign_known_attrs(record, {
-                                      status: 'processed',
-                                      processed_at: (if ModelUtils.has_columns?(@klass,
-                                                                                :processed_at)
-                                                       now
-                                                     end),
-                                      updated_at: (if ModelUtils.has_columns?(@klass,
-                                                                              :updated_at)
-                                                     now
-                                                   end)
-                                    })
-      record.save!
+      ActiveRecord::Base.transaction do
+        now = Time.now.utc
+        attrs = {
+          status: 'processed',
+          processed_at: record.respond_to?(:processed_at) ? now : nil,
+          updated_at: record.respond_to?(:updated_at) ? now : nil
+        }
+        ModelUtils.assign_known_attrs(record, attrs)
+        record.save!
+      end
     end
 
     def persist_failure(record, error)
       return unless record
 
-      now = Time.now.utc
-      ModelUtils.assign_known_attrs(record, {
-                                      status: (if ModelUtils.has_columns?(@klass,
-                                                                          :status)
-                                                 'failed'
-                                               end),
-                                      last_error: (if ModelUtils.has_columns?(@klass,
-                                                                              :last_error)
-                                                     "#{error.class}: #{error.message}"
-                                                   end),
-                                      updated_at: (if ModelUtils.has_columns?(@klass,
-                                                                              :updated_at)
-                                                     now
-                                                   end)
-                                    })
-      record.save!
+      ActiveRecord::Base.transaction do
+        now = Time.now.utc
+        attrs = {
+          status: 'failed',
+          last_error: "#{error.class}: #{error.message}",
+          updated_at: record.respond_to?(:updated_at) ? now : nil
+        }
+        ModelUtils.assign_known_attrs(record, attrs)
+        record.save!
+      end
     rescue StandardError => e
       Logging.warn("Failed to persist inbox failure: #{e.class}: #{e.message}",
                    tag: 'JetstreamBridge::Consumer')

data/lib/jetstream_bridge/consumer/message_processor.rb

@@ -1,12 +1,50 @@
 # frozen_string_literal: true
 
 require 'oj'
+require 'securerandom'
 require_relative '../core/logging'
-require_relative 'message_context'
 require_relative 'dlq_publisher'
-require_relative 'backoff_strategy'
 
 module JetstreamBridge
+  # Immutable per-message metadata.
+  MessageContext = Struct.new(
+    :event_id, :deliveries, :subject, :seq, :consumer, :stream,
+    keyword_init: true
+  ) do
+    def self.build(msg)
+      new(
+        event_id: msg.header&.[]('nats-msg-id') || SecureRandom.uuid,
+        deliveries: msg.metadata&.num_delivered.to_i,
+        subject: msg.subject,
+        seq: msg.metadata&.sequence,
+        consumer: msg.metadata&.consumer,
+        stream: msg.metadata&.stream
+      )
+    end
+  end
+
+  # Simple exponential backoff strategy for transient failures.
+  class BackoffStrategy
+    TRANSIENT_ERRORS = [Timeout::Error, IOError].freeze
+    MAX_EXPONENT     = 6
+    MAX_DELAY        = 60
+    MIN_DELAY        = 1
+
+    # Returns a bounded delay in seconds
+    def delay(deliveries, error)
+      base = transient?(error) ? 0.5 : 2.0
+      power = [deliveries - 1, MAX_EXPONENT].min
+      raw = (base * (2**power)).to_i
+      raw.clamp(MIN_DELAY, MAX_DELAY)
+    end
+
+    private
+
+    def transient?(error)
+      TRANSIENT_ERRORS.any? { |k| error.is_a?(k) }
+    end
+  end
+
   # Orchestrates parse → handler → ack/nak → DLQ
   class MessageProcessor
     UNRECOVERABLE_ERRORS = [ArgumentError, TypeError].freeze
@@ -25,12 +63,13 @@ module JetstreamBridge
 
       process_event(msg, event, ctx)
     rescue StandardError => e
+      backtrace = e.backtrace&.first(5)&.join("\n  ")
       Logging.error(
         "Processor crashed event_id=#{ctx&.event_id} subject=#{ctx&.subject} seq=#{ctx&.seq} " \
-        "deliveries=#{ctx&.deliveries} err=#{e.class}: #{e.message}",
+        "deliveries=#{ctx&.deliveries} err=#{e.class}: #{e.message}\n  #{backtrace}",
         tag: 'JetstreamBridge::Consumer'
       )
-      safe_nak(msg)
+      safe_nak(msg, ctx, e)
     end
 
     private
@@ -39,14 +78,22 @@ module JetstreamBridge
       data = msg.data
       Oj.load(data, mode: :strict)
     rescue Oj::ParseError => e
-      @dlq.publish(msg, ctx,
-                   reason: 'malformed_json', error_class: e.class.name, error_message: e.message)
-      msg.ack
-      Logging.warn(
-        "Malformed JSON → DLQ event_id=#{ctx.event_id} subject=#{ctx.subject} " \
-        "seq=#{ctx.seq} deliveries=#{ctx.deliveries}: #{e.message}",
-        tag: 'JetstreamBridge::Consumer'
-      )
+      dlq_success = @dlq.publish(msg, ctx,
+                                  reason: 'malformed_json', error_class: e.class.name, error_message: e.message)
+      if dlq_success
+        msg.ack
+        Logging.warn(
+          "Malformed JSON → DLQ event_id=#{ctx.event_id} subject=#{ctx.subject} " \
+          "seq=#{ctx.seq} deliveries=#{ctx.deliveries}: #{e.message}",
+          tag: 'JetstreamBridge::Consumer'
+        )
+      else
+        safe_nak(msg, ctx, e)
+        Logging.error(
+          "Malformed JSON, DLQ publish failed, NAKing event_id=#{ctx.event_id}",
+          tag: 'JetstreamBridge::Consumer'
+        )
+      end
       nil
     end
 
@@ -58,14 +105,22 @@ module JetstreamBridge
         tag: 'JetstreamBridge::Consumer'
       )
     rescue *UNRECOVERABLE_ERRORS => e
-      @dlq.publish(msg, ctx,
-                   reason: 'unrecoverable', error_class: e.class.name, error_message: e.message)
-      msg.ack
-      Logging.warn(
-        "DLQ (unrecoverable) event_id=#{ctx.event_id} subject=#{ctx.subject} " \
-        "seq=#{ctx.seq} deliveries=#{ctx.deliveries} err=#{e.class}: #{e.message}",
-        tag: 'JetstreamBridge::Consumer'
-      )
+      dlq_success = @dlq.publish(msg, ctx,
+                                  reason: 'unrecoverable', error_class: e.class.name, error_message: e.message)
+      if dlq_success
+        msg.ack
+        Logging.warn(
+          "DLQ (unrecoverable) event_id=#{ctx.event_id} subject=#{ctx.subject} " \
+          "seq=#{ctx.seq} deliveries=#{ctx.deliveries} err=#{e.class}: #{e.message}",
+          tag: 'JetstreamBridge::Consumer'
+        )
+      else
+        safe_nak(msg, ctx, e)
+        Logging.error(
+          "Unrecoverable error, DLQ publish failed, NAKing event_id=#{ctx.event_id}",
+          tag: 'JetstreamBridge::Consumer'
+        )
+      end
     rescue StandardError => e
       ack_or_nak(msg, ctx, e)
     end
@@ -73,14 +128,28 @@ module JetstreamBridge
     def ack_or_nak(msg, ctx, error)
       max_deliver = JetstreamBridge.config.max_deliver.to_i
       if ctx.deliveries >= max_deliver
-        @dlq.publish(msg, ctx,
-                     reason: 'max_deliver_exceeded', error_class: error.class.name, error_message: error.message)
-        msg.ack
-        Logging.warn(
-          "DLQ (max_deliver) event_id=#{ctx.event_id} subject=#{ctx.subject} " \
-          "seq=#{ctx.seq} deliveries=#{ctx.deliveries} err=#{error.class}: #{error.message}",
-          tag: 'JetstreamBridge::Consumer'
-        )
+        # Only ACK if DLQ publish succeeds
+        dlq_success = @dlq.publish(msg, ctx,
+                                    reason: 'max_deliver_exceeded',
+                                    error_class: error.class.name,
+                                    error_message: error.message)
+
+        if dlq_success
+          msg.ack
+          Logging.warn(
+            "DLQ (max_deliver) event_id=#{ctx.event_id} subject=#{ctx.subject} " \
+            "seq=#{ctx.seq} deliveries=#{ctx.deliveries} err=#{error.class}: #{error.message}",
+            tag: 'JetstreamBridge::Consumer'
+          )
+        else
+          # NAK to retry DLQ publish
+          safe_nak(msg, ctx, error)
+          Logging.error(
+            "DLQ publish failed at max_deliver, NAKing event_id=#{ctx.event_id} " \
+            "seq=#{ctx.seq} deliveries=#{ctx.deliveries}",
+            tag: 'JetstreamBridge::Consumer'
+          )
+        end
       else
         safe_nak(msg, ctx, error)
         Logging.warn(
@@ -91,11 +160,14 @@ module JetstreamBridge
       end
     end
 
-    def safe_nak(msg, ctx = nil, _error = nil)
-      # If your NATS client supports delayed NAKs, uncomment:
-      # delay = @backoff.delay(ctx&.deliveries.to_i, error) if ctx
-      # msg.nak(next_delivery_delay: delay)
-      msg.nak
+    def safe_nak(msg, ctx = nil, error = nil)
+      # Use backoff strategy with error context if available
+      if ctx && error && msg.respond_to?(:nak_with_delay)
+        delay = @backoff.delay(ctx.deliveries.to_i, error)
+        msg.nak_with_delay(delay)
+      else
+        msg.nak
+      end
     rescue StandardError => e
       Logging.error(
         "Failed to NAK event_id=#{ctx&.event_id} deliveries=#{ctx&.deliveries}: " \

data/lib/jetstream_bridge/consumer/subscription_manager.rb

@@ -2,7 +2,6 @@
 
 require_relative '../core/logging'
 require_relative '../core/duration'
-require_relative '../consumer/consumer_config'
 
 module JetstreamBridge
   # Encapsulates durable ensure + subscribe for a pull consumer.
@@ -11,7 +10,7 @@ module JetstreamBridge
       @jts     = jts
       @durable = durable
       @cfg     = cfg
-      @desired_cfg      = ConsumerConfig.consumer_config(@durable, filter_subject)
+      @desired_cfg      = build_consumer_config(@durable, filter_subject)
       @desired_cfg_norm = normalize_consumer_config(@desired_cfg)
     end
 
@@ -74,6 +73,18 @@ module JetstreamBridge
       )
     end
 
+    def build_consumer_config(durable, filter_subject)
+      {
+        durable_name: durable,
+        filter_subject: filter_subject,
+        ack_policy: 'explicit',
+        deliver_policy: 'all',
+        max_deliver: JetstreamBridge.config.max_deliver,
+        ack_wait: Duration.to_millis(JetstreamBridge.config.ack_wait),
+        backoff: Array(JetstreamBridge.config.backoff).map { |d| Duration.to_millis(d) }
+      }
+    end
+
     # Normalize both server-returned config objects and our desired hash
     # into a common hash with consistent units/types for accurate comparison.
     def normalize_consumer_config(cfg)