cosmonats 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ade68e6438fc5ea6cec3fd97bf2794c87f2117414c56c69e49e67544f35e7ab
-  data.tar.gz: db98a44b41d057795b6a9f8c56316252b4cad1ab2f2a07912a66e16c09a86013
+  metadata.gz: 1b9d8091f782c96278e0de951486f14f3207f8af37d99f5460d122ee61ab0616
+  data.tar.gz: 0e76adacb61e924afd50d127a0c5259c9c454827e75276b44fba0ba7879409a0
 SHA512:
-  metadata.gz: bd359b85f69bcdc85f800ec8dc0e4b24ff09e905851e412047dd96a0154c21b459bf52465493ee1a05c664968817828124fa35919cd7174d0f3c0ebe0ba867ca
-  data.tar.gz: dbb223d897a14e457bcf78085896ed0c7f1548eb7565621e35b62257879065dfb653d8cc58a396c921d508afe92e1b9640cbfd3cf9845d00ee471b577609ffa7
+  metadata.gz: 0277a84383b59f6c5fe7502a94f51619778aef691877dad39cf093733fbc69b8a2f4ac676006f4e67bf60db84af03ab49b741d38662652ce4fb017e1aef5f699
+  data.tar.gz: 2c850062acd3f24925e0136ef95ff7ea8c24a279f9ae7ad04526baea01524e46dcd266e8cc996d918a091fc39335d8283000dab56daffc46758e60ef17ea460b

data/README.md

@@ -364,7 +364,7 @@ consumers:
       priority: 5
     scheduled:
       <<: *consumer_config
-      max_deliver: 1
+      max_deliver: 5
       max_ack_pending: 100
       ack_wait: 10
 

data/lib/cosmo/client.rb

@@ -22,8 +22,13 @@ module Cosmo
       js.publish(subject, payload, **params)
     end
 
+    # Create a pull subscription. Durable with +consumer_name+, and ephemeral without.
+    # @param config [Hash] Consumer config. Ephemeral consumers additionally require
+    #   +:stream+ and +:inactive_threshold+ (seconds the consumer survives without a fetch).
     def subscribe(subject, consumer_name, config)
-      js.pull_subscribe(subject, consumer_name, config: config)
+      return js.pull_subscribe(subject, consumer_name, config: config) if consumer_name
+
+      ephemeral_subscribe(subject, config)
     end
 
     def stream_info(name)
@@ -103,6 +108,10 @@ module Cosmo
       js.consumer_info(stream_name, consumer_name)
     end
 
+    def delete_consumer(stream_name, consumer_name)
+      js.delete_consumer(stream_name, consumer_name)
+    end
+
     def get_message(stream_name, **options)
       js.get_msg(stream_name, **options)
     end
@@ -133,6 +142,32 @@ module Cosmo
 
     private
 
+    # NOTE: nats-pure's #pull_subscribe has no path to a true ephemeral pull consumer.
+    # Its rescue branch unconditionally sets `config[:durable_name] = durable` (jetstream.rb).
+    def ephemeral_subscribe(subject, config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      config = config.dup
+      stream = config.delete(:stream) or raise ArgumentError, "stream required for ephemeral consumers"
+      raise ArgumentError, "inactive_threshold required for ephemeral consumers" unless config[:inactive_threshold]
+
+      subject = subject.first if subject.is_a?(Array) && subject.size == 1
+      consumer_config = NATS::JetStream::API::ConsumerConfig.new(config)
+      if subject.is_a?(Array)
+        consumer_config[:filter_subjects] ||= subject
+      else
+        consumer_config[:filter_subject] ||= subject
+      end
+
+      info = js.add_consumer(stream, consumer_config)
+
+      sub = nc.subscribe(nc.new_inbox)
+      sub.extend(NATS::JetStream.const_get(:PullSubscription))
+      sub.jsi = NATS::JetStream.const_get(:JS)::Sub.new(
+        js: js, stream: stream, consumer: info.name,
+        nms: "#{js.prefix}.CONSUMER.MSG.NEXT.#{stream}.#{info.name}"
+      )
+      sub
+    end
+
     # NOTE: KV manager in nats-pure hardcodes the fields it copies into StreamConfig,
     # so `allow_msg_ttl` is never forwarded via create_key_value. Send the raw stream-create API request instead.
     def create_kv_with_msg_ttl(name, **options)

data/lib/cosmo/logger.rb

@@ -5,6 +5,8 @@ require "forwardable"
 
 module Cosmo
   module Logger
+    TRACE = -1 # Below DEBUG; opt in with COSMO_LOG_LEVEL=trace for high-frequency polling/loop noise
+
     module Context
       KEY = :cosmo_context
 
@@ -45,10 +47,21 @@ module Cosmo
       end
     end
 
+    # Adds TRACE (below DEBUG) on top of stdlib's fixed DEBUG..UNKNOWN severities.
+    class Instance < ::Logger
+      def trace(progname = nil, &)
+        add(TRACE, nil, progname, &)
+      end
+
+      def format_severity(severity)
+        severity == TRACE ? "TRACE" : super
+      end
+    end
+
     class << self
       extend Forwardable
 
-      delegate %i[info error debug warn fatal] => :instance
+      delegate %i[info error debug warn fatal trace] => :instance
     end
 
     def self.with(...)
@@ -60,12 +73,17 @@ module Cosmo
     end
 
     def self.instance
-      @instance ||= ::Logger.new($stdout).tap do |logger|
+      @instance ||= Instance.new($stdout).tap do |logger|
         logger.formatter = SimpleFormatter.new
-        logger.level = ::Logger::Severity.coerce(ENV.fetch("COSMO_LOG_LEVEL", "info"))
+        logger.level = coerce_level(ENV.fetch("COSMO_LOG_LEVEL", "info"))
       end
     end
 
+    def self.coerce_level(level)
+      level.to_s.downcase == "trace" ? TRACE : ::Logger::Severity.coerce(level)
+    end
+    private_class_method :coerce_level
+
     def self.instance=(logger)
       @instance = logger
     end

data/lib/cosmo/processor.rb

@@ -60,14 +60,14 @@ module Cosmo
           stream_name = config[:stream].to_s
           ttl = Utils::Duration.parse(ENV.fetch("COSMO_STREAM_PAUSED_RECHECK_TTL", STREAM_PAUSED_RECHECK_TTL))
           if @cache.fetch("#{stream_name}:paused", ttl:) { API::Stream.new(stream_name).paused? }
-            Logger.debug "stream #{stream_name} is paused, skipping fetch"
+            Logger.trace "stream #{stream_name} is paused, skipping fetch"
             next
           end
           all_paused = false
 
           _, skip_t = consumer_state[stream_name]
           if skip_t && Time.now < skip_t
-            Logger.debug "stream #{stream_name} is empty, backing off"
+            Logger.trace "stream #{stream_name} is empty, backing off"
             next
           end
           all_empty = false
@@ -79,9 +79,9 @@ module Cosmo
               next if skip_t && Time.now < skip_t
 
               timeout = fetch_timeout(config)
-              Logger.debug "fetching #{fetch_subjects(config).inspect}, timeout=#{timeout}"
-              messages = lock(stream_name) { fetch(subscription, batch_size: config[:batch_size], timeout:) }
-              Logger.debug "fetched (#{messages&.size.to_i}) messages"
+              Logger.trace "fetching #{fetch_subjects(config).inspect}, timeout=#{timeout}"
+              messages = fetch(subscription, batch_size: config[:batch_size], timeout:)
+              Logger.trace "fetched (#{messages&.size.to_i}) messages"
               if messages&.any?
                 consumer_state.delete(stream_name)
                 process(messages, processor)
@@ -104,14 +104,14 @@ module Cosmo
 
         if all_paused
           period = Utils::Duration.parse(ENV.fetch("COSMO_STREAMS_PAUSED_IDLE_SLEEP", STREAMS_PAUSED_IDLE_SLEEP))
-          Logger.debug "all streams paused, sleep=#{period}"
+          Logger.trace "all streams paused, sleep=#{period}"
           sleep(period)
         elsif all_empty
           next_wake = consumer_state.values.filter_map { |_, t| t }.min
           next unless next_wake # entry was deleted concurrently (messages arrived), re-loop immediately
 
           remaining = [next_wake - Time.now, 0.01].max
-          Logger.debug "all streams empty, sleep=#{remaining}"
+          Logger.trace "all streams empty, sleep=#{remaining}"
           sleep(remaining)
         end
       end
@@ -158,11 +158,6 @@ module Cosmo
       Utils::Stopwatch.new
     end
 
-    def lock(stream_name, &)
-      @locks ||= Hash.new { |h, k| h[k] = Mutex.new }
-      @locks[stream_name].synchronize(&)
-    end
-
     def consumer_state
       @consumer_state ||= Concurrent::Map.new
     end

data/lib/cosmo/utils/overrides.rb

@@ -13,3 +13,188 @@ Cosmo::Utils::Warnings.silence do
   members = NATS::JetStream::PubAck.members + [:val]
   NATS::JetStream::PubAck = Struct.new(*members, keyword_init: true)
 end
+
+# Upstream bug in nats-pure 2.5.0 (https://github.com/nats-io/nats.rb):
+# NATS::JetStream::PullSubscription#fetch only assigns its `start_time` local in the
+# `batch > 1` branch, but the final "did we time out" check outside the case statement
+# reads it unconditionally. For `batch == 1` (what Cosmo::Processor always uses),
+# `start_time` is nil there -- normally masked because the `batch == 1` branch has its
+# own timeout check (using a properly-set `t`) that raises first.
+#
+# It only surfaces once two threads call #fetch concurrently on the *same* subscription:
+# @pending_queue/wait_for_msgs_cond are shared per-subscription state, and #dispatch's
+# `wait_for_msgs_cond.signal` wakes exactly one arbitrary waiter -- not necessarily the
+# one whose own request produced that wakeup. A thread woken by someone else's signal
+# finds nothing left in the (already-drained) queue, so it skips its own inner timeout
+# check and falls into the buggy tail check, raising `TypeError: nil can't be coerced
+# into Float` instead of the intended timeout/empty result. Reproduced deterministically
+# with N threads fetching in a loop against the same PullSubscription.
+#
+# Second, separate upstream bug in the same method: the post-wait timeout check below
+# (`raise ... if MonotonicTime.since(t) > timeout`) fires unconditionally, unlike every
+# other timeout check in this method (all guarded with `msgs.empty? &&`). If the unsynchronized
+# pop just above it succeeded in grabbing a real, already-delivered message -- which can happen
+# even after `timeout` has technically elapsed, since #dispatch's signal and this thread actually
+# resuming are two different moments -- that message is already gone from @pending_queue with
+# nowhere else to go, yet gets discarded here and a plain NATS::Timeout raised instead. Callers
+# (including Cosmo::Processor#fetch) treat NATS::Timeout as "no messages", so the message is lost
+# silently: never processed, never acked, and not redelivered until the consumer's ack_wait expires.
+# Reproduces reliably with several threads fetching (batch: 1) concurrently against the same
+# subscription, e.g. Cosmo::Job::Processor's thread pool.
+#
+# Vendored copy of nats-pure's PullSubscription#fetch, kept as close to
+# upstream as possible (two one-line fixes, see comments above), so it's easy to diff against the
+# next nats-pure release and drop once fixed there.
+
+# rubocop:disable all
+module NATS
+  class JetStream
+    module PullSubscription
+      def fetch(batch = 1, params = {})
+        raise ::NATS::JetStream::Error.new("nats: invalid batch size") if batch < 1
+
+        t = MonotonicTime.now
+        start_time = t # fixes the upstream bug -- see comment above
+        timeout = params[:timeout] ||= 5
+        expires = (timeout * 1_000_000_000) - 100_000
+        next_req = { batch: batch }
+
+        msgs = []
+        case
+        when batch == 1
+          synchronize do
+            unless @pending_queue.empty?
+              msg = @pending_queue.pop
+              @pending_size -= msg.data.size
+              if JS.is_status_msg(msg)
+                case msg.header["Status"]
+                when JS::Status::NoMsgs then nil
+                when JS::Status::RequestTimeout then nil # Skip
+                else raise JS.from_msg(msg)
+                end
+              else
+                msgs << msg
+              end
+            end
+          end
+
+          next_req[:expires] = expires
+          if msgs.empty?
+            @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
+            synchronize { wait_for_msgs_cond.wait(timeout) }
+
+            unless @pending_queue.empty?
+              msg = @pending_queue.pop
+              @pending_size -= msg.data.size
+              msgs << msg
+            end
+
+            raise ::NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (MonotonicTime.since(t) > timeout)
+
+            if JS.is_status_msg(msgs.first)
+              msg = msgs.first
+              case msg.header[JS::Header::Status]
+              when JS::Status::RequestTimeout then raise NATS::Timeout.new("nats: fetch request timeout")
+              else raise JS.from_msg(msgs.first)
+              end
+            end
+          end
+        when batch > 1
+          synchronize do
+            if batch <= @pending_queue.size
+              batch.times do
+                msg = @pending_queue.pop
+                @pending_size -= msg.data.size
+                if JS.is_status_msg(msg)
+                  case msg.header[JS::Header::Status]
+                  when JS::Status::NoMsgs, JS::Status::RequestTimeout then next
+                  else raise JS.from_msg(msg)
+                  end
+                else
+                  msgs << msg
+                end
+              end
+              return msgs
+            end
+          end
+
+          next_req[:no_wait] = true
+          @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
+
+          start_time = MonotonicTime.now
+          msg = nil
+
+          synchronize do
+            wait_for_msgs_cond.wait(timeout)
+            unless @pending_queue.empty?
+              msg = @pending_queue.pop
+              @pending_size -= msg.data.size
+            end
+          end
+
+          if !msg.nil? && JS.is_status_msg(msg)
+            case msg.header[JS::Header::Status]
+            when JS::Status::NoMsgs
+              next_req[:expires] = expires
+              next_req.delete(:no_wait)
+              @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
+            when JS::Status::RequestTimeout
+              raise NATS::Timeout.new("nats: fetch request timeout")
+            else
+              raise JS.from_msg(msg)
+            end
+          else
+            msgs << msg unless msg.nil?
+          end
+
+          duration = MonotonicTime.since(start_time)
+          raise NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (duration > timeout)
+
+          needed = batch - msgs.count
+          while (needed > 0) && (MonotonicTime.since(start_time) < timeout)
+            duration = MonotonicTime.since(start_time)
+
+            synchronize do
+              if @pending_queue.empty?
+                deadline = timeout - duration
+                wait_for_msgs_cond.wait(deadline) if deadline > 0
+
+                duration = MonotonicTime.since(start_time)
+                if msgs.empty? && @pending_queue.empty? && (duration > timeout)
+                  raise NATS::Timeout.new("nats: fetch timeout")
+                end
+              end
+
+              unless @pending_queue.empty?
+                msg = @pending_queue.pop
+                @pending_size -= msg.data.size
+
+                if JS.is_status_msg(msg)
+                  case msg.header[JS::Header::Status]
+                  when JS::Status::NoMsgs, JS::Status::RequestTimeout
+                    duration = MonotonicTime.since(start_time)
+                    if duration > timeout
+                      raise NATS::Timeout.new("nats: fetch timeout") if msgs.empty?
+
+                      return msgs
+                    end
+                  else
+                    raise JS.from_msg(msg)
+                  end
+                else
+                  msgs << msg
+                  needed -= 1
+                end
+              end
+            end
+          end
+        end
+
+        raise ::NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (MonotonicTime.since(start_time) > timeout)
+
+        msgs
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/cosmo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cosmo
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/sig/cosmo/client.rbs

@@ -13,7 +13,7 @@ module Cosmo
 
     def publish: (::String subject, ::String payload, **untyped params) -> untyped
 
-    def subscribe: (::String | Array[::String] subject, ::String consumer_name, Hash[Symbol, untyped] config) -> untyped
+    def subscribe: (::String | Array[::String] subject, ::String? consumer_name, Hash[Symbol, untyped] config) -> untyped
 
     def stream_info: (::String | Symbol name) -> untyped
 
@@ -39,6 +39,8 @@ module Cosmo
 
     def consumer_info: (::String stream_name, ::String consumer_name) -> NATS::JetStream::API::ConsumerInfo
 
+    def delete_consumer: (::String stream_name, ::String consumer_name) -> bool
+
     def get_message: (::String | Symbol name, **untyped options) -> NATS::JetStream::API::RawStreamMsg
 
     def delete_message: (::String name, ::Integer seq) -> Hash[::String, untyped]
@@ -51,6 +53,8 @@ module Cosmo
 
     private
 
+    def ephemeral_subscribe: (::String | Array[::String] subject, Hash[Symbol, untyped] config) -> untyped
+
     def create_kv_with_msg_ttl: (::String name, **untyped opts) -> untyped
   end
 end

data/sig/cosmo/logger.rbs

@@ -1,5 +1,7 @@
 module Cosmo
   module Logger
+    TRACE: Integer
+
     module Context
       KEY: Symbol
 
@@ -20,6 +22,12 @@ module Cosmo
       def call: (::String severity, Time time, untyped _, ::String msg) -> ::String
     end
 
+    class Instance < ::Logger
+      def trace: (?::String? progname) ?{ () -> ::String } -> true
+
+      def format_severity: (Integer severity) -> ::String
+    end
+
     def self.info: (::String) -> void
 
     def self.error: (::String | Exception) -> void
@@ -30,6 +38,8 @@ module Cosmo
 
     def self.fatal: (::String) -> void
 
+    def self.trace: (::String | Exception) -> void
+
     def self.with: (**untyped) ?{ () -> void } -> void
 
     def self.without: (*Symbol) -> nil

data/sig/cosmo/processor.rbs

@@ -10,7 +10,6 @@ module Cosmo
     @threads: Array[Thread]
     @cache: Utils::TTLCache
     @options: Hash[Symbol, untyped]
-    @locks: Hash[::String, Mutex]
     @consumer_state: untyped
 
     def self.run: (*untyped) -> Processor
@@ -49,8 +48,6 @@ module Cosmo
 
     def stopwatch: () -> Utils::Stopwatch
 
-    def lock: (::String stream_name) { () -> void } -> void
-
     def consumer_state: () -> untyped
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cosmonats
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Dmitry Vorotilin