jetstream_bridge 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 535eaf5e00d6c27b8f79c3d065128e917c8acddb36a696f7a097c535e28a20e2
-  data.tar.gz: 0a6b2c99fea1b1f351b95664034ba879307182dbfaf2b67c399a9ff385ad96ab
+  metadata.gz: 6e2b2c796fab5fd06b35517459688fa9497130af361455ef16719e4cffcdaef5
+  data.tar.gz: 5464863f1c55c4798db4607dfb7cdd9ade28933685d02231ae56cedf2b113312
 SHA512:
-  metadata.gz: c0514b7de514f05785ca2208ce4613be7814702141c04bf5be3266b4f7b9e6d0406288d021715779efb23824fe45b5effa92ca4c9fc7f612586de7b97eb3cfe3
-  data.tar.gz: 9f9cde6bfad36b565a1f7f7aa0ff7b889a4758ff91f86ee663296f85ef676c759de3b1268dd03f7de323bb9561f8530fe25d9c57b784bd2a55138afd833844bf
+  metadata.gz: 108cde827d26a8840448163af5cce84c5b9f16d6952ce35b0e228c1f9314caf4a822cf196c760fa6e7bf2fe1e6dafc4f89d893ff927a157d7a8420a230ecae4e
+  data.tar.gz: b546a279f3b3fa7cd7481fa4c13c81da37c923262b76ba714a1ef828192ae08f74d5b2e65d13145bbc05795b9dd5c54b067eee4ece161e69e7965ed09c975e65

data/Gemfile.lock

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

data/lib/jetstream_bridge/consumer.rb

@@ -55,15 +55,44 @@ module JetstreamBridge
       JetstreamBridge.config.destination_subject
     end
 
+    def desired_consumer_cfg
+      ConsumerConfig.consumer_config(@durable, filter_subject)
+    end
+
     def ensure_consumer!
-      @jts.consumer_info(stream_name, @durable)
-      Logging.info("Consumer #{@durable} exists.", tag: 'JetstreamBridge::Consumer')
+      info = @jts.consumer_info(stream_name, @durable)
+      if consumer_mismatch?(info, desired_consumer_cfg)
+        Logging.warn(
+          "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
+          Logging.warn("Delete consumer #{@durable} ignored: #{e.class} #{e.message}",
+                       tag: 'JetstreamBridge::Consumer')
+        end
+        @jts.add_consumer(stream_name, **desired_consumer_cfg)
+        Logging.info("Created consumer #{@durable} (filter=#{filter_subject})",
+                     tag: 'JetstreamBridge::Consumer')
+      else
+        Logging.info("Consumer #{@durable} exists with desired config.",
+                     tag: 'JetstreamBridge::Consumer')
+      end
     rescue NATS::JetStream::Error
-      @jts.add_consumer(stream_name, **ConsumerConfig.consumer_config(@durable, filter_subject))
+      # Not found -> create fresh
+      @jts.add_consumer(stream_name, **desired_consumer_cfg)
       Logging.info("Created consumer #{@durable} (filter=#{filter_subject})",
                    tag: 'JetstreamBridge::Consumer')
     end
 
+    def consumer_mismatch?(info, desired_cfg)
+      cfg = info.config
+      (cfg.respond_to?(:filter_subject) ? cfg.filter_subject.to_s : cfg[:filter_subject].to_s) !=
+        desired_cfg[:filter_subject].to_s
+    end
+
     def subscribe!
       @psub = @jts.pull_subscribe(
         filter_subject,
@@ -100,7 +129,8 @@ module JetstreamBridge
     def recoverable_consumer_error?(error)
       msg = error.message.to_s
       msg =~ /consumer.*(not\s+found|deleted)/i ||
-        msg =~ /no\s+responders/i
+        msg =~ /no\s+responders/i ||
+        msg =~ /stream.*not\s+found/i
     end
   end
 end

data/lib/jetstream_bridge/overlap_guard.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
 
 require 'json'
+require_relative 'subject_matcher'
+require_relative 'logging'
 
 module JetstreamBridge
   # Checks for overlapping subjects.
   class OverlapGuard
     class << self
+      # Raise if any desired subjects conflict with other streams.
       def check!(jts, target_name, new_subjects)
         conflicts = overlaps(jts, target_name, new_subjects)
         return if conflicts.empty?
         raise conflict_message(target_name, conflicts)
       end
 
+      # Return a list of conflicts against other streams, per subject.
+      # [{ name:'OTHER' pairs: [['a.b.*', 'a.b.c'], ...] }, ...]
       def overlaps(jts, target_name, new_subjects)
         desired = Array(new_subjects).map!(&:to_s).uniq
         streams = list_streams_with_subjects(jts)
@@ -26,6 +31,19 @@ module JetstreamBridge
         end.compact
       end
 
+      # Returns [allowed, blocked] given desired subjects.
+      def partition_allowed(jts, target_name, desired_subjects)
+        desired   = Array(desired_subjects).map!(&:to_s).uniq
+        conflicts = overlaps(jts, target_name, desired)
+        blocked   = conflicts.flat_map { |c| c[:pairs].map(&:first) }.uniq
+        allowed   = desired - blocked
+        [allowed, blocked]
+      end
+
+      def allowed_subjects(jts, target_name, desired_subjects)
+        partition_allowed(jts, target_name, desired_subjects).first
+      end
+
       def list_streams_with_subjects(jts)
         list_stream_names(jts).map do |name|
           info = jts.stream_info(name)

data/lib/jetstream_bridge/publisher.rb

@@ -47,7 +47,7 @@ module JetstreamBridge
       true
     end
 
-    # Retry only on transient NATS errors
+    # Retry only on transient NATS IO errors
     def with_retries(retries = DEFAULT_RETRIES)
       attempts = 0
       begin

data/lib/jetstream_bridge/stream.rb

@@ -12,34 +12,82 @@ module JetstreamBridge
         desired = normalize_subjects(subjects)
         raise ArgumentError, 'subjects must not be empty' if desired.empty?
 
+        attempts = 0
+
         begin
           info     = jts.stream_info(name)
           existing = normalize_subjects(info.config.subjects || [])
 
           # Skip anything already COVERED by existing patterns (not just exact match)
-          missing = desired.reject { |d| SubjectMatcher.covered?(existing, d) }
-          if missing.empty?
+          to_add = desired.reject { |d| SubjectMatcher.covered?(existing, d) }
+          if to_add.empty?
             Logging.info("Stream #{name} exists; subjects already covered.", tag: 'JetstreamBridge::Stream')
             return
           end
 
-          # Validate full target set against other streams
-          target = (existing + missing).uniq
-          OverlapGuard.check!(jts, name, target)
+          # Filter out subjects owned by other streams to prevent overlap BadRequest
+          allowed, blocked = OverlapGuard.partition_allowed(jts, name, to_add)
+
+          if allowed.empty?
+            if blocked.any?
+              Logging.warn(
+                "Stream #{name}: all missing subjects are owned by other streams; leaving unchanged. " \
+                  "blocked=#{blocked.inspect}",
+                tag: 'JetstreamBridge::Stream'
+              )
+            else
+              Logging.info("Stream #{name} exists; nothing to add.", tag: 'JetstreamBridge::Stream')
+            end
+            return
+          end
 
-          # Try to update; handle late overlaps/races
+          target = (existing + allowed).uniq
+
+          # Validate and update (race may still occur; handled in rescue)
+          OverlapGuard.check!(jts, name, target)
           jts.update_stream(name: name, subjects: target)
-          Logging.info("Updated stream #{name}; added subjects=#{missing.inspect}", tag: 'JetstreamBridge::Stream')
+
+          Logging.info(
+            "Updated stream #{name}; added subjects=#{allowed.inspect}" \
+              "#{blocked.any? ? " (skipped overlapped=#{blocked.inspect})" : ''}",
+            tag: 'JetstreamBridge::Stream'
+          )
         rescue NATS::JetStream::Error => e
           if stream_not_found?(e)
-            # Race: created elsewhere or genuinely missing — create fresh
-            OverlapGuard.check!(jts, name, desired)
-            jts.add_stream(name: name, subjects: desired, retention: 'interest', storage: 'file')
-            Logging.info("Created stream #{name} subjects=#{desired.inspect}", tag: 'JetstreamBridge::Stream')
+            # Creating fresh: still filter to avoid BadRequest
+            allowed, blocked = OverlapGuard.partition_allowed(jts, name, desired)
+            if allowed.empty?
+              Logging.warn(
+                "Not creating stream #{name}: all desired subjects are owned by other streams. " \
+                  "blocked=#{blocked.inspect}",
+                tag: 'JetstreamBridge::Stream'
+              )
+              return
+            end
+
+            jts.add_stream(
+              name: name,
+              subjects: allowed,
+              retention: 'interest',
+              storage: 'file'
+            )
+            Logging.info(
+              "Created stream #{name} subjects=#{allowed.inspect}" \
+                "#{blocked.any? ? " (skipped overlapped=#{blocked.inspect})" : ''}",
+              tag: 'JetstreamBridge::Stream'
+            )
+          elsif overlap_error?(e) && (attempts += 1) <= 1
+            # Late race: re-fetch and try once more
+            Logging.warn("Overlap race while ensuring #{name}; retrying once...", tag: 'JetstreamBridge::Stream')
+            sleep(0.05)
+            retry
           elsif overlap_error?(e)
-            # Late overlap due to concurrent change — recompute and raise with details
-            conflicts = OverlapGuard.overlaps(jts, name, desired)
-            raise OverlapGuard.conflict_message(name, conflicts)
+            # Give up gracefully (don’t raise) — someone else now owns a conflicting subject
+            Logging.warn(
+              "Overlap persists ensuring #{name}; leaving unchanged. err=#{e.message.inspect}",
+              tag: 'JetstreamBridge::Stream'
+            )
+            return
           else
             raise
           end

data/lib/jetstream_bridge/subject_matcher.rb

@@ -11,7 +11,7 @@ module JetstreamBridge
 
     # Proper NATS semantics:
     # - '*' matches exactly one token
-    # - '>' matches the rest (zero or more tokens) but ONLY after the fixed prefix matches
+    # - '>' matches the rest (zero or more tokens)
     def match?(pattern, subject)
       p = pattern.split('.')
       s = subject.split('.')
@@ -30,9 +30,10 @@ module JetstreamBridge
         i += 1
       end
 
-      # If the pattern still has tokens, it only matches if the remainder is a '>' (or contains one)
+      # Exact match
       return true if i == p.length && i == s.length
 
+      # If pattern has remaining '>' it can absorb remainder
       p[i] == '>' || p[i..-1]&.include?('>')
     end
 
@@ -47,8 +48,8 @@ module JetstreamBridge
       while ai < a_parts.length && bi < b_parts.length
         at = a_parts[ai]
         bt = b_parts[bi]
-        return true if at == '>' || bt == '>'                # either can absorb the rest
-        return false unless at == bt || at == '*' || bt == '*' # fixed tokens differ
+        return true if at == '>' || bt == '>'
+        return false unless at == bt || at == '*' || bt == '*'
         ai += 1
         bi += 1
       end

data/lib/jetstream_bridge/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jetstream_bridge
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Mike Attara
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 2025-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord