jetstream_bridge 4.5.0 → 4.5.2

data/lib/jetstream_bridge/consumer/subscription_manager.rb

@@ -2,6 +2,7 @@
 
 require_relative '../core/logging'
 require_relative '../core/duration'
+require_relative '../errors'
 
 module JetstreamBridge
   # Encapsulates durable ensure + subscribe for a pull consumer.
@@ -10,10 +11,7 @@ module JetstreamBridge
       @jts     = jts
       @durable = durable
       @cfg     = cfg
-      return if @cfg.disable_js_api
-
-      @desired_cfg      = build_consumer_config(@durable, filter_subject)
-      @desired_cfg_norm = normalize_consumer_config(@desired_cfg)
+      @desired_cfg = build_consumer_config(@durable, filter_subject)
     end
 
     def stream_name
@@ -28,64 +26,69 @@ module JetstreamBridge
       @desired_cfg
     end
 
-    def ensure_consumer!
-      if @cfg.disable_js_api
-        Logging.info("JS API disabled; assuming consumer #{@durable} exists", tag: 'JetstreamBridge::Consumer')
+    def ensure_consumer!(force: false)
+      # Runtime path: never hit JetStream management APIs to avoid admin permissions.
+      unless force || @cfg.auto_provision
+        log_runtime_skip
         return
       end
 
-      info = consumer_info_or_nil
-      return create_consumer! unless info
-
-      have_norm = normalize_consumer_config(info.config)
-      if have_norm == @desired_cfg_norm
-        log_consumer_ok
-      else
-        log_consumer_diff(have_norm)
-        recreate_consumer!
-      end
+      create_consumer!
     end
 
     # Bind a pull subscriber to the existing durable.
     def subscribe!
-      opts = { stream: stream_name }
-      if @cfg.disable_js_api
-        opts[:bind] = true
-      else
-        opts[:config] = desired_consumer_cfg
+      # Always bypass consumer_info to avoid requiring JetStream API permissions at runtime.
+      subscribe_without_verification!
+    end
+
+    def subscribe_without_verification!
+      # Manually create a pull subscription without calling consumer_info
+      # This bypasses the permission check in nats-pure's pull_subscribe
+      nc = resolve_nc
+
+      if nc.respond_to?(:new_inbox) && nc.respond_to?(:subscribe)
+        prefix = @jts.instance_variable_get(:@prefix) || '$JS.API'
+        deliver = nc.new_inbox
+        sub = nc.subscribe(deliver)
+
+        # Extend with PullSubscription module to add fetch methods
+        sub.extend(NATS::JetStream::PullSubscription)
+
+        # Set up the JSI (JetStream Info) struct that PullSubscription expects
+        # This matches what nats-pure does in pull_subscribe
+        subject = "#{prefix}.CONSUMER.MSG.NEXT.#{stream_name}.#{@durable}"
+        sub.jsi = NATS::JetStream::JS::Sub.new(
+          js: @jts,
+          stream: stream_name,
+          consumer: @durable,
+          nms: subject
+        )
+
+        Logging.info(
+          "Created pull subscription without verification for consumer #{@durable} " \
+          "(stream=#{stream_name}, filter=#{filter_subject})",
+          tag: 'JetstreamBridge::Consumer'
+        )
+
+        return sub
       end
 
-      @jts.pull_subscribe(
-        filter_subject,
-        @durable,
-        **opts
-      )
-    end
-
-    private
-
-    def consumer_info_or_nil
-      @jts.consumer_info(stream_name, @durable)
-    rescue NATS::JetStream::Error
-      nil
-    end
-
-    # ---- comparison ----
-
-    def log_consumer_diff(have_norm)
-      want_norm = @desired_cfg_norm
-
-      diffs = {}
-      (have_norm.keys | want_norm.keys).each do |k|
-        diffs[k] = { have: have_norm[k], want: want_norm[k] } unless have_norm[k] == want_norm[k]
+      # Fallback for environments (mocks/tests) where low-level NATS client is unavailable.
+      if @jts.respond_to?(:pull_subscribe)
+        Logging.info(
+          "Using pull_subscribe fallback for consumer #{@durable} (stream=#{stream_name})",
+          tag: 'JetstreamBridge::Consumer'
+        )
+        return @jts.pull_subscribe(filter_subject, @durable, stream: stream_name)
       end
 
-      Logging.warn(
-        "Consumer #{@durable} config mismatch (filter=#{filter_subject}) diff=#{diffs}",
-        tag: 'JetstreamBridge::Consumer'
-      )
+      raise JetstreamBridge::ConnectionError,
+            'Unable to create subscription without verification: NATS client not available'
     end
 
+    private
+
     def build_consumer_config(durable, filter_subject)
       {
         durable_name: durable,
@@ -93,36 +96,12 @@ module JetstreamBridge
         ack_policy: 'explicit',
         deliver_policy: 'all',
         max_deliver: JetstreamBridge.config.max_deliver,
-        # JetStream expects nanoseconds for ack_wait/backoff.
-        ack_wait: duration_to_nanos(JetstreamBridge.config.ack_wait),
-        backoff: Array(JetstreamBridge.config.backoff).map { |d| duration_to_nanos(d) }
+        # JetStream expects seconds (the client multiplies by nanoseconds).
+        ack_wait: duration_to_seconds(JetstreamBridge.config.ack_wait),
+        backoff: Array(JetstreamBridge.config.backoff).map { |d| duration_to_seconds(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)
-      {
-        filter_subject: sval(cfg, :filter_subject), # string
-        ack_policy: sval(cfg, :ack_policy), # string
-        deliver_policy: sval(cfg, :deliver_policy), # string
-        max_deliver: ival(cfg, :max_deliver), # integer
-        ack_wait_nanos: nanos(cfg, :ack_wait),
-        backoff_nanos: nanos_arr(cfg, :backoff)
-      }
-    end
-
-    # ---- lifecycle helpers ----
-
-    def recreate_consumer!
-      Logging.warn(
-        "Consumer #{@durable} exists with mismatched config; recreating (filter=#{filter_subject})",
-        tag: 'JetstreamBridge::Consumer'
-      )
-      safe_delete_consumer
-      create_consumer!
-    end
-
     def create_consumer!
       @jts.add_consumer(stream_name, **desired_consumer_cfg)
       Logging.info(
@@ -131,22 +110,6 @@ module JetstreamBridge
       )
     end
 
-    def log_consumer_ok
-      Logging.info(
-        "Consumer #{@durable} exists with desired config.",
-        tag: 'JetstreamBridge::Consumer'
-      )
-    end
-
-    def safe_delete_consumer
-      @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
-
     # ---- cfg access/normalization (struct-like or hash-like) ----
 
     def get(cfg, key)
@@ -164,58 +127,71 @@ module JetstreamBridge
       v.to_i
     end
 
-    # ---- duration coercion ----
-
-    def nanos(cfg, key)
+    # Normalize duration-like field to **milliseconds** (Integer).
+    # Accepts:
+    # - Strings:"500ms""30s" "2m", "1h", "250us", "100ns"
+    # - Integers/Floats:
+    #     * Server may return large integers in **nanoseconds** → detect and convert.
+    #     * Otherwise, we delegate to Duration.to_millis (heuristic/explicit).
+    def d_secs(cfg, key)
       raw = get(cfg, key)
-      duration_to_nanos(raw)
+      duration_to_seconds(raw)
     end
 
-    def nanos_arr(cfg, key)
+    # Normalize array of durations to integer milliseconds.
+    def darr_secs(cfg, key)
       raw = get(cfg, key)
-      Array(raw).map { |d| duration_to_nanos(d) }
+      Array(raw).map { |d| duration_to_seconds(d) }
     end
 
-    def duration_to_nanos(val)
+    # ---- duration coercion ----
+
+    def duration_to_seconds(val)
       return nil if val.nil?
 
       case val
       when Integer
-        # Heuristic: extremely large integers are likely already nanoseconds
-        return val if val >= 1_000_000_000 # >= 1s in nanos
+        # Heuristic: extremely large integers are likely **nanoseconds** from server
+        # (e.g., 30s => 30_000_000_000 ns). Convert ns → seconds.
+        return (val / 1_000_000_000.0).round if val >= 1_000_000_000
 
+        # otherwise rely on Duration’s :auto heuristic (int <1000 => seconds, >=1000 => ms)
         millis = Duration.to_millis(val, default_unit: :auto)
-        (millis * 1_000_000).to_i
+        seconds_from_millis(millis)
       when Float
         millis = Duration.to_millis(val, default_unit: :auto)
-        (millis * 1_000_000).to_i
+        seconds_from_millis(millis)
       when String
-        millis = Duration.to_millis(val) # unit-aware
-        (millis * 1_000_000).to_i
+        # Strings include unit (ns/us/ms/s/m/h/d) handled by Duration
+        millis = Duration.to_millis(val) # default_unit ignored when unit given
+        seconds_from_millis(millis)
       else
-        return duration_to_nanos(val.to_f) if val.respond_to?(:to_f)
+        return duration_to_seconds(val.to_f) if val.respond_to?(:to_f)
 
         raise ArgumentError, "invalid duration: #{val.inspect}"
       end
     end
 
-    # Legacy helper used in specs; kept for backward compatibility.
-    def duration_to_seconds(val)
-      return nil if val.nil?
+    def seconds_from_millis(millis)
+      # Always round up to avoid zero-second waits when sub-second durations are provided.
+      [(millis / 1000.0).ceil, 1].max
+    end
 
-      case val
-      when Integer
-        return (val / 1_000_000_000.0).round if val >= 1_000_000_000 # nanoseconds
-        return val if val < 1000 # seconds
+    def log_runtime_skip
+      Logging.info(
+        "Skipping consumer provisioning/verification for #{@durable} at runtime to avoid JetStream API usage. " \
+        'Ensure it is pre-created via provisioning.',
+        tag: 'JetstreamBridge::Consumer'
+      )
+    end
 
-        (val / 1000.0).round # milliseconds as integer
-      when Float
-        val
-      else
-        millis = Duration.to_millis(val, default_unit: :auto)
-        seconds = millis / 1000.0
-        seconds < 1 ? 1 : seconds.round(3)
-      end
+    def resolve_nc
+      return @jts.nc if @jts.respond_to?(:nc)
+      return @jts.instance_variable_get(:@nc) if @jts.instance_variable_defined?(:@nc)
+
+      return @cfg.mock_nats_client if @cfg.respond_to?(:mock_nats_client) && @cfg.mock_nats_client
+
+      nil
     end
   end
 end

data/lib/jetstream_bridge/core/bridge_helpers.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+require_relative 'connection'
+
+module JetstreamBridge
+  module Core
+    # Internal helper methods extracted from the main JetstreamBridge module
+    # to keep the public API surface focused.
+    module BridgeHelpers
+      private
+
+      # Ensure connection is established before use
+      # Automatically connects on first use if not already connected
+      # Thread-safe and idempotent
+      def connect_if_needed!
+        return if @connection_initialized
+
+        startup!
+      end
+
+      # Enforce rate limit on uncached health checks to prevent abuse
+      # Max 1 uncached request per 5 seconds per process
+      def enforce_health_check_rate_limit!
+        @health_check_mutex ||= Mutex.new
+        @health_check_mutex.synchronize do
+          now = Time.now
+          if @last_uncached_health_check
+            time_since = now - @last_uncached_health_check
+            if time_since < 5
+              raise HealthCheckFailedError,
+                    "Health check rate limit exceeded. Please wait #{(5 - time_since).ceil} second(s)"
+            end
+          end
+          @last_uncached_health_check = now
+        end
+      end
+
+      def fetch_stream_info
+        return skipped_stream_info unless config.auto_provision
+
+        # Ensure we have an active connection before querying stream info
+        connect_if_needed!
+
+        jts = Connection.jetstream
+        raise ConnectionNotEstablishedError, 'NATS connection not established' unless jts
+
+        stream_info_payload(jts.stream_info(config.stream_name))
+      rescue StandardError => e
+        stream_error_payload(e)
+      end
+
+      def measure_nats_rtt
+        nc = Connection.nc
+        return nil unless nc
+
+        # Prefer native RTT API when available (e.g., new NATS clients)
+        if nc.respond_to?(:rtt)
+          rtt_value = normalize_ms(nc.rtt)
+          return rtt_value if rtt_value
+        end
+
+        # Fallback for clients without #rtt (nats-pure): measure ping/pong via flush
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        nc.flush(1)
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        normalize_ms(duration)
+      rescue StandardError => e
+        Logging.warn(
+          "Failed to measure NATS RTT: #{e.class} #{e.message}",
+          tag: 'JetstreamBridge'
+        )
+        nil
+      end
+
+      def normalize_ms(value)
+        return nil if value.nil?
+        return nil unless value.respond_to?(:to_f)
+
+        numeric = value.to_f
+        # Heuristic: sub-1 values are likely seconds; convert them to ms for reporting
+        ms = numeric < 1 ? numeric * 1000 : numeric
+        ms.round(2)
+      end
+
+      def assign_config_option!(cfg, key, val)
+        setter = :"#{key}="
+        raise ArgumentError, "Unknown configuration option: #{key}" unless cfg.respond_to?(setter)
+
+        cfg.public_send(setter, val)
+      end
+
+      def stream_info_payload(info)
+        config_data = info.config
+        state_data = info.state
+
+        {
+          exists: true,
+          name: config.stream_name,
+          subjects: extract_field(config_data, :subjects),
+          messages: extract_field(state_data, :messages)
+        }
+      end
+
+      def extract_field(data, key)
+        data.respond_to?(key) ? data.public_send(key) : data[key]
+      end
+
+      def stream_error_payload(error)
+        {
+          exists: false,
+          name: config.stream_name,
+          error: "#{error.class}: #{error.message}"
+        }
+      end
+
+      def skipped_stream_info
+        {
+          exists: nil,
+          name: config.stream_name,
+          skipped: true,
+          reason: 'auto_provision=false (skip $JS.API.STREAM.INFO)'
+        }
+      end
+    end
+  end
+end