jetstream_bridge 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e2b2c796fab5fd06b35517459688fa9497130af361455ef16719e4cffcdaef5
-  data.tar.gz: 5464863f1c55c4798db4607dfb7cdd9ade28933685d02231ae56cedf2b113312
+  metadata.gz: 52210d5d38366eed432001bc5ae522574a09fa73e5327e6509fc2a3983d7e2f5
+  data.tar.gz: fc9b02992b70a4584396177226cb1c21a83a87c96384d227825d6ffa9dcab958
 SHA512:
-  metadata.gz: 108cde827d26a8840448163af5cce84c5b9f16d6952ce35b0e228c1f9314caf4a822cf196c760fa6e7bf2fe1e6dafc4f89d893ff927a157d7a8420a230ecae4e
-  data.tar.gz: b546a279f3b3fa7cd7481fa4c13c81da37c923262b76ba714a1ef828192ae08f74d5b2e65d13145bbc05795b9dd5c54b067eee4ece161e69e7965ed09c975e65
+  metadata.gz: bbb2379b20b45f15f5fded1bd4da19a0b5b2e12ba6df321e66b6a15bf00bb2be292dc8b4ec379d0223508c145689d8374531512d757a72cb397474d1794339ef
+  data.tar.gz: 119109cd2c60ab8885f8a47d33d7fb9e4e74a91ee39217bc1cfcbf13e6e4d5e64ebb7bfe8b7b1fcc4f4df39c72f12972b2e675d85e85a869c40d1ef92b106b8d

data/.idea/dictionaries/project.xml

@@ -3,6 +3,7 @@
     <words>
       <w>activesupport</w>
       <w>backoffs</w>
+      <w>dedup</w>
       <w>esub</w>
       <w>msgs</w>
       <w>pipefail</w>

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jetstream_bridge (1.5.0)
+    jetstream_bridge (1.6.0)
       activerecord (>= 6.0)
       activesupport (>= 6.0)
       nats-pure (~> 2.4)

data/README.md

@@ -1,18 +1,19 @@
 # Jetstream Bridge
 
 **Production-safe realtime data bridge** between systems using **NATS JetStream**.
-Includes durable consumers, backpressure, retries, **DLQ**, and optional **Inbox/Outbox** for end-to-end reliability.
+Includes durable consumers, backpressure, retries, **DLQ**, optional **Inbox/Outbox**, and **overlap-safe stream provisioning**.
 
 ---
 
 ## ✨ Features
 
-- 🔌 Simple **Publisher** and **Consumer** interfaces
-- 🛡 **Outbox** (reliable send) & **Inbox** (idempotent receive)
-- 🧨 **DLQ** for poison messages
-- ⚙️ Durable `pull_subscribe` with exponential backoff & `max_deliver`
-- 🎯 Configurable **source** and **destination** applications
-- 📊 Built-in observability
+* 🔌 Simple **Publisher** and **Consumer** interfaces
+* 🛡 **Outbox** (reliable send) & **Inbox** (idempotent receive), opt-in
+* 🧨 **DLQ** for poison messages
+* ⚙️ Durable `pull_subscribe` with backoff & `max_deliver`
+* 🎯 Clear **source/destination** subject conventions
+* 🧱 **Overlap-safe stream ensure** (prevents “subjects overlap” BadRequest)
+* 📊 Built-in logging for visibility
 
 ---
 
@@ -34,31 +35,32 @@ bundle install
 ```ruby
 # config/initializers/jetstream_bridge.rb
 JetstreamBridge.configure do |config|
-  # NATS Connection
+  # NATS connection
   config.nats_urls       = ENV.fetch("NATS_URLS", "nats://localhost:4222")
-  config.env             = ENV.fetch("NATS_ENV", "development")
-  config.app_name        = ENV.fetch("APP_NAME", "app")
-  config.destination_app = ENV["DESTINATION_APP"]
+  config.env             = ENV.fetch("NATS_ENV",  "development")
+  config.app_name        = ENV.fetch("APP_NAME",  "app")
+  config.destination_app = ENV["DESTINATION_APP"] # required
 
-  # Consumer Tuning
+  # Consumer tuning
   config.max_deliver = 5
   config.ack_wait    = "30s"
   config.backoff     = %w[1s 5s 15s 30s 60s]
 
-  # Reliability Features
+  # Reliability features (opt-in)
   config.use_outbox = true
   config.use_inbox  = true
   config.use_dlq    = true
 
-  # Models (override if custom)
+  # Models (override if you use custom AR classes/table names)
   config.outbox_model = "JetstreamBridge::OutboxEvent"
   config.inbox_model  = "JetstreamBridge::InboxEvent"
 end
 ```
 
-> **Note:**
-> - `stream_name` defaults to `{env}-stream-bridge`
-> - `dlq_subject` defaults to `data.sync.dlq`
+> **Defaults:**
+>
+> * `stream_name` → `#{env}-jetstream-bridge-stream`
+> * `dlq_subject` → `#{env}.data.sync.dlq`
 
 ---
 
@@ -70,50 +72,69 @@ end
 | **Subscribe** | `{env}.data.sync.{dest}.{app}` |
 | **DLQ**       | `{env}.data.sync.dlq`          |
 
-- `{app}`: Your `app_name`
-- `{dest}`: Your `destination_app`
-- `{env}`: Your `env``
+* `{app}`: `app_name`
+* `{dest}`: `destination_app`
+* `{env}`: `env`
 
 ---
 
-## 🗃 Database Setup (Inbox/Outbox)
+## 🧱 Stream Topology (auto-ensure & overlap-safe)
 
-Run the installer:
+On first connection, Jetstream Bridge **ensures** a single stream exists for your `env` and that it covers:
 
-```bash
-rails jetstream_bridge:install --all
-```
+* `source_subject` (`{env}.data.sync.{app}.{dest}`)
+* `destination_subject` (`{env}.data.sync.{dest}.{app}`)
+* `dlq_subject` (if enabled)
+
+It’s **overlap-safe**:
+
+* Skips adding subjects already covered by existing wildcards.
+* Pre-filters subjects that belong to *other* streams to avoid `BadRequest: subjects overlap with an existing stream`.
+* Retries once on concurrent races, then logs and continues safely.
+
+---
+
+## 🗃 Database Setup (Inbox / Outbox)
 
-This creates:
+Inbox/Outbox are **optional**. The library detects columns at runtime and only sets those that exist, so you can start minimal and evolve later.
 
-1. **Initializer** (`config/initializers/jetstream_bridge.rb`)
-2. **Migrations** (if enabled):
+### Minimal schemas (recommended starting point)
 
 ```ruby
-# Outbox
-create_table :jetstream_outbox_events do |t|
-  t.string  :resource_type, null: false
-  t.string  :resource_id,   null: false
-  t.string  :event_type,    null: false
-  t.jsonb   :payload,       null: false, default: {}
-  t.datetime :published_at
-  t.integer  :attempts,     default: 0
-  t.text     :last_error
+# db/migrate/xxxx_create_outbox_events.rb
+create_table :outbox_events do |t|
+  t.string  :event_id, null: false, index: { unique: true }
+  t.string  :subject,  null: false
+  t.jsonb   :payload,  null: false, default: {}   # stored envelope or payload
+  t.jsonb   :headers,  null: false, default: {}   # e.g., { "Nats-Msg-Id": ... }
+  t.string  :status,   null: false, default: "pending" # pending|publishing|sent|failed
+  t.integer :attempts, null: false, default: 0
+  t.text    :last_error
+  t.datetime :enqueued_at
+  t.datetime :sent_at
   t.timestamps
 end
-add_index :jetstream_outbox_events, [:resource_type, :resource_id]
 
-# Inbox
-create_table :jetstream_inbox_events do |t|
-  t.string   :event_id,  null: false
-  t.string   :subject,   null: false
+# db/migrate/xxxx_create_inbox_events.rb
+create_table :inbox_events do |t|
+  t.string   :event_id, index: { unique: true }   # dedupe key (preferred)
+  t.string   :subject,  null: false
+  t.jsonb    :payload,  null: false, default: {}
+  t.jsonb    :headers,  null: false, default: {}
+  t.string   :stream
+  t.bigint   :stream_seq
+  t.integer  :deliveries
+  t.string   :status,   null: false, default: "received" # received|processing|processed|failed
+  t.text     :last_error
+  t.datetime :received_at
   t.datetime :processed_at
-  t.text     :error
   t.timestamps
 end
-add_index :jetstream_inbox_events, :event_id, unique: true
 ```
 
+> Already have tables named differently (e.g., `jetstream_outbox_events`)?
+> Set `config.outbox_model` / `config.inbox_model` to your AR class names.
+
 ---
 
 ## 📤 Publish Events
@@ -122,33 +143,20 @@ add_index :jetstream_inbox_events, :event_id, unique: true
 publisher = JetstreamBridge::Publisher.new
 publisher.publish(
   resource_type: "user",
-  resource_id:   "01H1234567890ABCDEF",
   event_type:    "created",
-  payload:       { id: "01H...", name: "Ada" }
+  payload:       { id: "01H...", name: "Ada" },  # resource_id inferred from payload[:id] / payload["id"]
+  # optional:
+  # event_id: "uuid-or-ulid",
+  # trace_id: "hex",
+  # occurred_at: Time.now.utc
 )
 ```
 
-> **Ephemeral Mode** (for short-lived scripts):
-> ```ruby
-> JetstreamBridge::Publisher.new(persistent: false).publish(...)
-> ```
+* If **Outbox** is enabled, the publish call:
 
----
-
-## 🔄 Outbox (If Enabled)
-
-Events are written to the Outbox table. Flush periodically:
-
-```ruby
-# app/jobs/outbox_flush_job.rb
-class OutboxFlushJob < ApplicationJob
-  def perform
-    JetstreamBridge::Publisher.new.flush_outbox
-  end
-end
-```
-
-Schedule this job to run every minute.
+    * Upserts an outbox row by `event_id`
+    * Publishes with `Nats-Msg-Id` (idempotent)
+    * Marks status `sent` or records `failed` with `last_error`
 
 ---
 
@@ -156,58 +164,91 @@ Schedule this job to run every minute.
 
 ```ruby
 JetstreamBridge::Consumer.new(
-  durable_name: "#{Rails.env}-peerapp-events",
+  durable_name: "#{Rails.env}-peerapp-consumers",
   batch_size:   25
 ) do |event, subject, deliveries|
   # Your idempotent domain logic here
-  UserCreatedHandler.call(event.payload)
+  # `event` is the parsed envelope hash
+  UserCreatedHandler.call(event["payload"])
 end.run!
 ```
 
+* If **Inbox** is enabled, the consumer:
+
+    * Dedupes by `event_id` (falls back to stream sequence if needed)
+    * Records processing state, errors, and timestamps
+    * Skips already-processed messages (acks immediately)
+
 ---
 
 ## 📬 Envelope Format
 
-Published events include:
-
 ```json
 {
   "event_id":       "01H1234567890ABCDEF",
   "schema_version": 1,
+  "event_type":     "created",
   "producer":       "myapp",
   "resource_type":  "user",
   "resource_id":    "01H1234567890ABCDEF",
-  "event_type":     "created",
   "occurred_at":    "2025-08-13T21:00:00Z",
   "trace_id":       "abc123",
   "payload":        { "id": "01H...", "name": "Ada" }
 }
 ```
 
+* `resource_id` is inferred from `payload.id` when publishing.
+
+---
+
+## 🧨 Dead-Letter Queue (DLQ)
+
+When enabled, the topology ensures the DLQ subject exists:
+**`{env}.data.sync.dlq`**
+
+You may run a separate process to subscribe and triage messages that exceed `max_deliver` or are NAK’ed to the DLQ.
+
 ---
 
 ## 🛠 Operations Guide
 
 ### Monitoring
-- **Consumer Lag**: `nats consumer info <stream> <durable>`
-- **Outbox Growth**: Alert if `jetstream_outbox_events` grows unexpectedly
-- **DLQ Messages**: Monitor `data.sync.dlq` subscription
+
+* **Consumer lag**: `nats consumer info <stream> <durable>`
+* **DLQ volume**: subscribe/metrics on `{env}.data.sync.dlq`
+* **Outbox backlog**: alert on `outbox_events` with `status != 'sent'` and growing count
 
 ### Scaling
-- Run consumers in **separate processes/containers**
-- Scale independently of web workers
+
+* Run consumers in **separate processes/containers**
+* Scale consumers independently from web
+* Tune `batch_size`, `ack_wait`, `max_deliver`, and `backoff`
 
 ### When to Use
-- **Inbox**: When replays or duplicates are possible
-- **Outbox**: When "DB commit ⇒ event published" guarantee is required
+
+* **Inbox**: you need idempotent processing and replay safety
+* **Outbox**: you want “DB commit ⇒ event published (or recorded for retry)” guarantees
+
+---
+
+## 🧩 Troubleshooting
+
+* **`subjects overlap with an existing stream`**
+  The library pre-filters overlapping subjects and retries once. If another team owns a broad wildcard (e.g., `env.data.sync.>`), coordinate subject boundaries.
+
+* **Consumer exists with mismatched filter**
+  The library detects and recreates the durable with the desired filter subject.
+
+* **Repeated redeliveries**
+  Increase `ack_wait`, review handler acks/NACKs, or move poison messages to DLQ.
 
 ---
 
 ## 🚀 Getting Started
 
-1. Install the gem 
-2. Configure the initializer 
-3. Run migrations: `rails db:migrate`
+1. Add the gem & run `bundle install`
+2. Create the initializer
+3. (Optional) Add Inbox/Outbox migrations and models
 4. Start publishing/consuming!
 
 ---

data/lib/jetstream_bridge/consumer.rb

@@ -8,6 +8,7 @@ require_relative 'logging'
 require_relative 'consumer_config'
 require_relative 'message_processor'
 require_relative 'config'
+require_relative 'model_utils'
 
 module JetstreamBridge
   # Subscribes to "{env}.data.sync.{dest}.{app}" and processes messages.
@@ -66,7 +67,6 @@ module JetstreamBridge
           "Consumer #{@durable} exists with mismatched config; recreating (filter=#{filter_subject})",
           tag: 'JetstreamBridge::Consumer'
         )
-        # Be tolerant if delete fails due to races
         begin
           @jts.delete_consumer(stream_name, @durable)
         rescue NATS::JetStream::Error => e
@@ -81,7 +81,6 @@ module JetstreamBridge
                      tag: 'JetstreamBridge::Consumer')
       end
     rescue NATS::JetStream::Error
-      # Not found -> create fresh
       @jts.add_consumer(stream_name, **desired_consumer_cfg)
       Logging.info("Created consumer #{@durable} (filter=#{filter_subject})",
                    tag: 'JetstreamBridge::Consumer')
@@ -107,12 +106,19 @@ module JetstreamBridge
     # Returns number of messages processed; 0 on timeout/idle or after recovery.
     def process_batch
       msgs = @psub.fetch(@batch_size, timeout: FETCH_TIMEOUT_SECS)
-      msgs.each { |m| @processor.handle_message(m) }
-      msgs.size
+      count = 0
+      msgs.each do |m|
+        if JetstreamBridge.config.use_inbox
+          count += (process_with_inbox(m) ? 1 : 0)
+        else
+          @processor.handle_message(m)
+          count += 1
+        end
+      end
+      count
     rescue NATS::Timeout, NATS::IO::Timeout
       0
     rescue NATS::JetStream::Error => e
-      # Handle common recoverable states by re-ensuring consumer & subscription.
       if recoverable_consumer_error?(e)
         Logging.warn("Recovering subscription after error: #{e.class} #{e.message}",
                      tag: 'JetstreamBridge::Consumer')
@@ -126,6 +132,96 @@ module JetstreamBridge
       end
     end
 
+    # ----- Inbox path -----
+    def process_with_inbox(m)
+      klass = ModelUtils.constantize(JetstreamBridge.config.inbox_model)
+
+      unless ModelUtils.ar_class?(klass)
+        Logging.warn("Inbox model #{klass} is not an ActiveRecord model; processing directly.",
+                     tag: 'JetstreamBridge::Consumer')
+        @processor.handle_message(m)
+        return true
+      end
+
+      meta      = (m.respond_to?(:metadata) && m.metadata) || nil
+      seq       = meta&.respond_to?(:stream_sequence) ? meta.stream_sequence : nil
+      deliveries= meta&.respond_to?(:num_delivered)   ? meta.num_delivered   : nil
+      subject   = m.subject.to_s
+      headers   = (m.header || {})
+      body_str  = m.data
+      begin
+        body = JSON.parse(body_str)
+      rescue
+        body = {}
+      end
+
+      event_id  = (headers['Nats-Msg-Id'] || body['event_id']).to_s.strip
+      now       = Time.now.utc
+
+      # Prefer event_id; fallback to the stream sequence (and subject) if the schema differs
+      record = if ModelUtils.has_columns?(klass, :event_id)
+                 klass.find_or_initialize_by(event_id: (event_id.presence || "seq:#{seq}"))
+               elsif ModelUtils.has_columns?(klass, :stream_seq)
+                 klass.find_or_initialize_by(stream_seq: seq)
+               else
+                 klass.new
+               end
+
+      # If already processed, just ACK and skip handler
+      if record.respond_to?(:processed_at) && record.processed_at
+        m.ack
+        return true
+      end
+
+      # Create/update the inbox row before processing (idempotency + audit)
+      ModelUtils.assign_known_attrs(record, {
+        event_id:      (ModelUtils.has_columns?(klass, :event_id) ? (event_id.presence || "seq:#{seq}") : nil),
+        subject:       subject,
+        payload:       ModelUtils.json_dump(body.empty? ? body_str : body),
+        headers:       ModelUtils.json_dump(headers),
+        stream:        (ModelUtils.has_columns?(klass, :stream) ? meta&.stream : nil),
+        stream_seq:    (ModelUtils.has_columns?(klass, :stream_seq) ? seq : nil),
+        deliveries:    (ModelUtils.has_columns?(klass, :deliveries) ? deliveries : nil),
+        status:        'processing',
+        last_error:    nil,
+        received_at:   (ModelUtils.has_columns?(klass, :received_at) ? (record.received_at || now) : nil),
+        updated_at:    (ModelUtils.has_columns?(klass, :updated_at) ? now : nil)
+      })
+      record.save!
+
+      # Hand off to your processor (expected to ack/nak on its own)
+      @processor.handle_message(m)
+
+      ModelUtils.assign_known_attrs(record, {
+        status:       'processed',
+        processed_at: (ModelUtils.has_columns?(klass, :processed_at) ? Time.now.utc : nil),
+        updated_at:   (ModelUtils.has_columns?(klass, :updated_at) ? Time.now.utc : nil)
+      })
+      record.save!
+
+      true
+    rescue => e
+      # Try to persist the failure state; allow JetStream redelivery policy to handle retries
+      begin
+        if record
+          ModelUtils.assign_known_attrs(record, {
+            status:     'failed',
+            last_error: "#{e.class}: #{e.message}",
+            updated_at: (ModelUtils.has_columns?(klass, :updated_at) ? Time.now.utc : nil)
+          })
+          record.save!
+        end
+      rescue => e2
+        Logging.warn("Failed to persist inbox failure: #{e2.class}: #{e2.message}",
+                     tag: 'JetstreamBridge::Consumer')
+      end
+      Logging.error("Inbox processing failed: #{e.class}: #{e.message}",
+                    tag: 'JetstreamBridge::Consumer')
+      # We do NOT ack here; let your MessageProcessor (or JS policy) handle redelivery/DLQ
+      false
+    end
+    # ----- /Inbox path -----
+
     def recoverable_consumer_error?(error)
       msg = error.message.to_s
       msg =~ /consumer.*(not\s+found|deleted)/i ||

data/lib/jetstream_bridge/model_utils.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module JetstreamBridge
+  module ModelUtils
+    module_function
+
+    def constantize(name)
+      name.to_s.split('::').reduce(Object) { |m, c| m.const_get(c) }
+    end
+
+    def ar_class?(klass)
+      defined?(ActiveRecord::Base) && klass <= ActiveRecord::Base
+    end
+
+    def has_columns?(klass, *cols)
+      return false unless ar_class?(klass)
+      cols.flatten.all? { |c| klass.column_names.include?(c.to_s) }
+    end
+
+    def assign_known_attrs(record, attrs)
+      attrs.each do |k, v|
+        setter = :"#{k}="
+        record.public_send(setter, v) if record.respond_to?(setter)
+      end
+    end
+
+    # find_or_initialize_by on the first keyset whose columns exist; else new
+    def find_or_init_by_best(klass, *keysets)
+      keysets.each do |keys|
+        next if keys.nil? || keys.empty?
+        if has_columns?(klass, keys.keys)
+          return klass.find_or_initialize_by(keys)
+        end
+      end
+      klass.new
+    end
+
+    def json_dump(obj)
+      obj.is_a?(String) ? obj : JSON.generate(obj)
+    rescue
+      obj.to_s
+    end
+
+    def json_load(str)
+      return str if str.is_a?(Hash)
+      JSON.parse(str.to_s)
+    rescue
+      {}
+    end
+  end
+end

data/lib/jetstream_bridge/publisher.rb

@@ -5,6 +5,7 @@ require 'securerandom'
 require_relative 'connection'
 require_relative 'logging'
 require_relative 'config'
+require_relative 'model_utils'
 
 module JetstreamBridge
   # Publishes to "{env}.data.sync.{app}.{dest}".
@@ -27,7 +28,12 @@ module JetstreamBridge
       ensure_destination!
       envelope = build_envelope(resource_type, event_type, payload, options)
       subject  = JetstreamBridge.config.source_subject
-      with_retries { do_publish(subject, envelope) }
+
+      if JetstreamBridge.config.use_outbox
+        publish_via_outbox(subject, envelope)
+      else
+        with_retries { do_publish(subject, envelope) }
+      end
     rescue StandardError => e
       log_error(false, e)
     end
@@ -47,6 +53,85 @@ module JetstreamBridge
       true
     end
 
+    # ---- Outbox path ----
+    def publish_via_outbox(subject, envelope)
+      klass = ModelUtils.constantize(JetstreamBridge.config.outbox_model)
+
+      unless ModelUtils.ar_class?(klass)
+        Logging.warn("Outbox model #{klass} is not an ActiveRecord model; publishing directly.",
+                     tag: 'JetstreamBridge::Publisher')
+        return with_retries { do_publish(subject, envelope) }
+      end
+
+      now = Time.now.utc
+      event_id = envelope['event_id'].to_s
+
+      record = ModelUtils.find_or_init_by_best(
+        klass,
+        { event_id: event_id },
+        # Fallback key if app uses a different unique column:
+        { dedup_key: event_id }
+      )
+
+      # If already sent, do nothing
+      if record.respond_to?(:sent_at) && record.sent_at
+        Logging.info("Outbox already sent event_id=#{event_id}; skipping publish.",
+                     tag: 'JetstreamBridge::Publisher')
+        return true
+      end
+
+      # populate / update
+      ModelUtils.assign_known_attrs(record, {
+        event_id:      event_id,
+        subject:       subject,
+        payload:       ModelUtils.json_dump(envelope),
+        headers:       ModelUtils.json_dump({ 'Nats-Msg-Id' => event_id }),
+        status:        'publishing',
+        attempts:      (record.respond_to?(:attempts) ? (record.attempts || 0) + 1 : nil),
+        last_error:    nil,
+        enqueued_at:   (record.respond_to?(:enqueued_at) ? (record.enqueued_at || now) : nil),
+        updated_at:    (record.respond_to?(:updated_at) ? now : nil)
+      })
+      record.save!
+
+      ok = with_retries { do_publish(subject, envelope) }
+
+      if ok
+        ModelUtils.assign_known_attrs(record, {
+          status:   'sent',
+          sent_at:  (record.respond_to?(:sent_at) ? now : nil),
+          updated_at: (record.respond_to?(:updated_at) ? now : nil)
+        })
+        record.save!
+      else
+        ModelUtils.assign_known_attrs(record, {
+          status:     'failed',
+          last_error: 'Publish returned false',
+          updated_at: (record.respond_to?(:updated_at) ? now : nil)
+        })
+        record.save!
+      end
+
+      ok
+    rescue => e
+      # Persist the failure on the outbox row as best as we can
+      begin
+        if record
+          ModelUtils.assign_known_attrs(record, {
+            status:     'failed',
+            last_error: "#{e.class}: #{e.message}",
+            updated_at: (record.respond_to?(:updated_at) ? Time.now.utc : nil)
+          })
+          record.save!
+        end
+      rescue => e2
+        Logging.warn("Failed to persist outbox failure: #{e2.class}: #{e2.message}",
+                     tag: 'JetstreamBridge::Publisher')
+      end
+      log_error(false, e)
+    end
+    # ---- /Outbox path ----
+
     # Retry only on transient NATS IO errors
     def with_retries(retries = DEFAULT_RETRIES)
       attempts = 0

data/lib/jetstream_bridge/version.rb

@@ -4,5 +4,5 @@
 #
 # Version constant for the gem.
 module JetstreamBridge
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jetstream_bridge
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Mike Attara
@@ -197,6 +197,7 @@ files:
 - lib/jetstream_bridge/inbox_event.rb
 - lib/jetstream_bridge/logging.rb
 - lib/jetstream_bridge/message_processor.rb
+- lib/jetstream_bridge/model_utils.rb
 - lib/jetstream_bridge/outbox_event.rb
 - lib/jetstream_bridge/overlap_guard.rb
 - lib/jetstream_bridge/publisher.rb