nats-pure 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dbc568f99c60cbe6a338d5aca7d9311e22624400cdb16e35b06d14c029815d8
-  data.tar.gz: 0f5108f668ccf94894e827896dc0cdd7c3b3c0026130e2ed05c7808d933b931a
+  metadata.gz: 7d5c22758be6db2c05382a55c718c2c4f836a2c723f77820d4728bbf1538f30b
+  data.tar.gz: 1745fb8cfa406b598099779a027a3cc3dcc4cee28c22fd7c08e1b156b6ce4a5b
 SHA512:
-  metadata.gz: bb75b0dba73b2f0bf83c591e6416d67bc8722f583a1170bf83fc40eb536b598439e701c7b32335d3d1050efbbe3f34f865e4a8d7259bcd35a9f5247348453281
-  data.tar.gz: 8362a52a4309761638939795d66ef007f58856d19f3971110488ef3ee7b08f7e14077eaf237749571a744fa5c8eef0b36bb822e1a7ac8f9440503a9e6b245010
+  metadata.gz: 84b049092f60f34c3ca6b5a8ac2b4334a1a32dbaefd2659424f91db3472df105604bbddd4989793a56757a9cdee1c710db6b52fc02e40b95f64bc0b0eae21dd6
+  data.tar.gz: 38585616a5820faefe491c8c16d815bc52759e0cd2b7f77ab5b3a0227d3728720c4f1ac56d6d2af6354c2c53e54245ab48ce71c2a063efe3fe737e60e21c6af7

data/CHANGELOG.md

@@ -1,3 +1,30 @@
 # Change log
 
 ## main
+
+## v2.6.0
+
+This release prepares nats-pure for nats-server 2.16, whose new JetStream
+acknowledgement format breaks JetStream consumers and KV watchers in earlier
+versions, and fixes a deadlock that could hang `Client#close`.
+
+### Changed
+
+- With `reconnect: false`, losing the connection now closes the client, as nats.go does: the status becomes `CLOSED`, the close callback is called, and `publish` raises `NATS::IO::ConnectionClosedError`. It used to stay `DISCONNECTED` and keep accepting publishes that were never sent, because the close, started from the read loop, killed the read loop part way through. (#189)
+
+### Fixed
+
+- JetStream: accept the 11-token acknowledgement subjects that nats-server 2.16 sends by default (the v2 format of ADR-15). Earlier versions fail to read the metadata of every JetStream message from such a server, which breaks pull and push consumers and KV watchers. (#185)
+- JetStream: an unrecognized acknowledgement subject raises `NATS::JetStream::Error::NotJSMessage` instead of `NameError`, and subjects whose numeric fields do not parse are rejected. (#185)
+- JetStream: message metadata timestamps keep their full nanosecond precision. (#185)
+- KV: watchers track their position from message metadata, so they resume after a server restart with either acknowledgement format. (#185)
+- `Client#close` could hang forever. It stopped the client's background threads with `Thread#exit`, and killing a thread that is waiting for the client lock can lose Ruby's mutex wakeup, leaving `close` asleep on an unlocked lock. The threads are now asked to stop and joined, on close and on reconnect. (#183, #189)
+- A close while a reconnect was under way did not stick: the reconnect carried on, connected again and restarted the client, subscriptions included. (#189)
+- A subscription with a concurrency limit could run its callbacks in parallel, and so out of order: an empty pending queue released the concurrency permit twice. (#186)
+- A subscription could stop processing messages for good after a reconnect: shutting down the executor during dispatch killed the read loop and leaked the concurrency permit. (#182)
+- WebSocket: protocol lines sharing a frame, such as the `PONG` and `INFO` that nats-server 2.12.2 sends together, were misparsed (#174, thanks @artyomb), and bytes that arrived with the reply to the connect handshake were lost. (#182, #186)
+- JRuby: a refused connection raises `Errno::ECONNREFUSED`, as on MRI. (#182, #186)
+
+### Improved
+
+- Tested against nats-server 2.14, 2.15 and the upcoming 2.16 (`main`), on Ruby 3.0 to 3.4 and JRuby. (#182, #188)

data/lib/nats/io/client.rb

@@ -221,6 +221,10 @@ module NATS
       # Track whether connect has been already been called.
       @connect_called = false
 
+      # Bumped by every close, so that a reconnect started earlier can tell
+      # that the connection was closed meanwhile.
+      @close_generation = 0
+
       # New style request/response implementation.
       @resp_sub = nil
       @resp_map = nil
@@ -1293,6 +1297,11 @@ module NATS
     # Handles errors from reading, parsing the protocol or stale connection.
     # the lock should not be held entering this function.
     def process_op_error(e)
+      # A background thread being stopped by close or a reconnect sees
+      # errors from that; it must not start another close or reconnect,
+      # which would wait for the thread that is stopping it.
+      return if stopping?
+
       should_bail = synchronize do
         connecting? || closed? || reconnecting?
       end
@@ -1320,23 +1329,29 @@ module NATS
 
     def initiate_reconnect
       @status = RECONNECTING
-      @io&.close
+      old_io = @io
       @io = nil
 
+      # Wake a read loop blocked on the socket by shutting it down, and
+      # close the socket only once the loop has stopped: on JRuby a close
+      # right after the shutdown can leave the read blocked for good.
+      if @read_loop_thread&.alive? && @read_loop_thread != Thread.current
+        old_io&.shutdown_read
+      end
+
       # TODO: Reconnecting pending buffer?
 
+      generation = @close_generation
+
       # Do reconnect under a different thread than the one
       # in which we got the error.
       Thread.new do
-        # Abort currently running reads in case they're around
-        # FIXME: There might be more graceful way here...
-        @read_loop_thread.exit if @read_loop_thread.alive?
-        @flusher_thread.exit if @flusher_thread.alive?
-        @ping_interval_thread.exit if @ping_interval_thread.alive?
+        stop_threads!
+        old_io&.close
 
         @subscription_executor.shutdown
 
-        attempt_reconnect
+        attempt_reconnect(generation)
       rescue NATS::IO::NoServersError => e
         @last_err = e
         close
@@ -1346,6 +1361,8 @@ module NATS
     # Gathers data from the socket and sends it to the parser.
     def read_loop
       loop do
+        return if stopping?
+
         should_bail = synchronize do
           # FIXME: In case of reconnect as well?
           @status == CLOSED or @status == RECONNECTING
@@ -1361,6 +1378,9 @@ module NATS
         # FIXME: We do not really need a timeout here...
         retry
       rescue => e
+        # Asked to stop: the error comes from the socket being shut down.
+        return if stopping?
+
         # In case of reading/parser errors, trigger
         # reconnection logic in case desired.
         process_op_error(e)
@@ -1373,6 +1393,7 @@ module NATS
       loop do
         # Blocks waiting for the flusher to be kicked...
         @flush_queue.pop
+        return if stopping?
 
         should_bail = synchronize do
           (@status != CONNECTED && !draining?) || @status == CONNECTING
@@ -1411,9 +1432,9 @@ module NATS
       end
     end
 
-    def ping_interval_loop
+    def ping_interval_loop(stop)
       loop do
-        sleep @options[:ping_interval]
+        return if stop.wait(@options[:ping_interval])
 
         # Skip ping interval until connected
         next if !connected?
@@ -1486,8 +1507,11 @@ module NATS
       end
     end
 
-    # Reconnect logic, this is done while holding the lock.
-    def attempt_reconnect
+    # Reconnect logic. generation is @close_generation from when the
+    # reconnect started; a close since then cancels the reconnect.
+    def attempt_reconnect(generation)
+      return if closed_since?(generation)
+
       @disconnect_cb&.call(@last_err)
 
       # Clear sticky error
@@ -1496,6 +1520,8 @@ module NATS
       # Do reconnect
       srv = nil
       begin
+        return if closed_since?(generation)
+
         srv = select_next_server
 
         # Set hostname to use for TLS hostname verification
@@ -1537,37 +1563,49 @@ module NATS
         retry
       end
 
-      # Clear pending flush calls and reset state before restarting loops
-      @flush_queue.clear
-      @pings_outstanding = 0
-      @pongs_received = 0
+      # Under the lock, so that a concurrent close either cancels this or
+      # finds the new connection in place and closes it.
+      synchronize do
+        if @close_generation != generation
+          @io.close
+          @io = nil
+          return
+        end
 
-      # Replay all subscriptions
-      @subs.each_pair do |sid, sub|
-        @io.write("SUB #{sub.subject} #{sub.queue} #{sid}#{CR_LF}")
-      end
+        # Clear pending flush calls and reset state before restarting loops
+        @flush_queue.clear
+        @pings_outstanding = 0
+        @pongs_received = 0
 
-      # Flush anything which was left pending, in case of errors during flush
-      # then we should raise error then retry the reconnect logic
-      cmds = []
-      cmds << @pending_queue.pop until @pending_queue.empty?
-      @io.write(cmds.join) unless cmds.empty?
-      @status = CONNECTED
-      @pending_size = 0
+        # Replay all subscriptions
+        @subs.each_pair do |sid, sub|
+          @io.write("SUB #{sub.subject} #{sub.queue} #{sid}#{CR_LF}")
+        end
 
-      # Reset parser state here to avoid unknown protocol errors
-      # on reconnect...
-      @parser.reset!
+        # Flush anything which was left pending, in case of errors during flush
+        # then we should raise error then retry the reconnect logic
+        cmds = []
+        cmds << @pending_queue.pop until @pending_queue.empty?
+        @io.write(cmds.join) unless cmds.empty?
+        @status = CONNECTED
+        @pending_size = 0
 
-      # Now connected to NATS, and we can restart parser loop, flusher
-      # and ping interval
-      start_threads!
+        # Reset parser state here to avoid unknown protocol errors
+        # on reconnect...
+        @parser.reset!
+
+        # Now connected to NATS, and we can restart parser loop, flusher
+        # and ping interval
+        start_threads!
+      end
 
-      # Dispatch the reconnected callback while holding lock
-      # which we should have already
       @reconnect_cb&.call
     end
 
+    def closed_since?(generation)
+      synchronize { @close_generation != generation }
+    end
+
     def close_connection(conn_status, do_cbs = true)
       synchronize do
         @connect_called = false
@@ -1575,25 +1613,10 @@ module NATS
           @status = conn_status
           return
         end
+        @close_generation += 1
       end
 
-      # Kick the flusher so it bails due to closed state
-      @flush_queue << :fallout if @flush_queue
-      Thread.pass
-
-      # FIXME: More graceful way of handling the following?
-      # Ensure ping interval and flusher are not running anymore
-      if @ping_interval_thread&.alive?
-        @ping_interval_thread.exit
-      end
-
-      if @flusher_thread&.alive?
-        @flusher_thread.exit
-      end
-
-      if @read_loop_thread&.alive?
-        @read_loop_thread.exit
-      end
+      stop_threads!
 
       @subscription_executor&.shutdown
       @subscription_executor&.wait_for_termination(options[:close_timeout])
@@ -1642,21 +1665,58 @@ module NATS
       end
     end
 
+    # Asks the read loop, flusher and ping threads to stop, wakes them from
+    # wherever they block, and waits for them to finish.
+    #
+    # They are never killed: Thread#exit on a thread that is waiting for
+    # the client lock can swallow the lock's wakeup, so that the next
+    # thread waiting for the lock sleeps forever on an unlocked lock (#183).
+    def stop_threads!(timeout = NATS::IO::THREADS_STOP_TIMEOUT)
+      threads = [@read_loop_thread, @flusher_thread, @ping_interval_thread].compact
+      threads.each { |t| t[:nats_stop]&.stop! } # also wakes the ping thread
+
+      begin
+        @flush_queue&.push(:fallout, true)
+      rescue ThreadError
+        # Queue is full, so the flusher is awake already.
+      end
+      # Wake the read loop if it is blocked on the socket. Only while it
+      # runs: shutdown acts on the socket itself, which a forked child
+      # (whose threads are gone) shares with the parent.
+      if @read_loop_thread&.alive? && @read_loop_thread != Thread.current
+        @io&.shutdown_read
+      end
+
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      threads.each do |t|
+        next if t == Thread.current
+
+        t.join([deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max)
+      end
+    end
+
+    def stopping?
+      Thread.current[:nats_stop]&.stopped?
+    end
+
+    def start_thread(name, stop, &block)
+      thread = Thread.new(&block)
+      thread[:nats_stop] = stop
+      thread.name = name
+      thread.abort_on_exception = true
+      thread
+    end
+
     def start_threads!
       # Reading loop for gathering data
-      @read_loop_thread = Thread.new { read_loop }
-      @read_loop_thread.name = "nats:read_loop"
-      @read_loop_thread.abort_on_exception = true
+      @read_loop_thread = start_thread("nats:read_loop", NATS::IO::StopSignal.new) { read_loop }
 
       # Flusher loop for sending commands
-      @flusher_thread = Thread.new { flusher_loop }
-      @flusher_thread.name = "nats:flusher_loop"
-      @flusher_thread.abort_on_exception = true
+      @flusher_thread = start_thread("nats:flusher_loop", NATS::IO::StopSignal.new) { flusher_loop }
 
       # Ping interval handling for keeping alive the connection
-      @ping_interval_thread = Thread.new { ping_interval_loop }
-      @ping_interval_thread.name = "nats:ping_loop"
-      @ping_interval_thread.abort_on_exception = true
+      ping_stop = NATS::IO::StopSignal.new
+      @ping_interval_thread = start_thread("nats:ping_loop", ping_stop) { ping_interval_loop(ping_stop) }
 
       # Subscription handling thread pool
       @subscription_executor = Concurrent::ThreadPoolExecutor.new(
@@ -1889,6 +1949,44 @@ module NATS
     DEFAULT_DRAIN_TIMEOUT = 30
     DEFAULT_CLOSE_TIMEOUT = 30
 
+    # How long to wait for the read loop, flusher and ping threads to
+    # stop on close or reconnect.
+    THREADS_STOP_TIMEOUT = 5
+
+    # Asks a background thread to stop, and lets it sleep until then.
+    class StopSignal
+      def initialize
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @stopped = false
+      end
+
+      def stop!
+        @mutex.synchronize do
+          @stopped = true
+          @cond.broadcast
+        end
+      end
+
+      def stopped?
+        @stopped
+      end
+
+      # Sleeps up to timeout seconds; returns whether stop! was called.
+      def wait(timeout)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        @mutex.synchronize do
+          until @stopped
+            left = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            break if left <= 0
+
+            @cond.wait(@mutex, left)
+          end
+          @stopped
+        end
+      end
+    end
+
     # Default Pending Limits
     DEFAULT_SUB_PENDING_MSGS_LIMIT = 65536
     DEFAULT_SUB_PENDING_BYTES_LIMIT = 65536 * 1024
@@ -2004,6 +2102,15 @@ module NATS
         @socket.close
       end
 
+      # Makes a read blocked on the socket in another thread return,
+      # while writes keep working.
+      def shutdown_read
+        io = @socket.respond_to?(:to_io) ? @socket.to_io : @socket
+        io.shutdown(::Socket::SHUT_RD)
+      rescue IOError, SystemCallError
+        # Already closed or not connected.
+      end
+
       def closed?
         @socket.closed?
       end
@@ -2030,6 +2137,12 @@ module NATS
         end
 
         sock
+      rescue IOError => e
+        # JRuby raises a plain IOError for a refused connection.
+        if (RUBY_ENGINE == "jruby") && e.message.include?("Connection refused")
+          raise Errno::ECONNREFUSED
+        end
+        raise
       end
     end
   end

data/lib/nats/io/jetstream/manager.rb

@@ -231,7 +231,7 @@ module NATS
 
         data = req.to_json
         if params[:direct]
-          if params[:subject] && !(params[:seq])
+          if params[:subject] && !params[:seq]
             # last_by_subject type request requires no payload.
             data = ""
             req_subject = "#{@prefix}.DIRECT.GET.#{stream_name}.#{params[:subject]}"

data/lib/nats/io/jetstream/msg/ack.rb

@@ -43,15 +43,19 @@ module NATS
         Timestamp = 9
         NumPending = 10
 
+        # Positions of fields that must be unsigned integers (ADR-15).
+        NumericTokens = [NumDelivered, StreamSeq, ConsumerSeq, Timestamp, NumPending].freeze
+        Digits = /\A\d+\z/
+
         # Subject without domain:
         # $JS.ACK.<stream>.<consumer>.<delivered>.<sseq>.<cseq>.<tm>.<pending>
         #
         V1TokenCounts = 9
 
-        # Subject with domain:
-        # $JS.ACK.<domain>.<account hash>.<stream>.<consumer>.<delivered>.<sseq>.<cseq>.<tm>.<pending>.<a token with a random value>
+        # Subject with domain, 11 or more tokens; the server may append more (ADR-15):
+        # $JS.ACK.<domain>.<account hash>.<stream>.<consumer>.<delivered>.<sseq>.<cseq>.<tm>.<pending>
         #
-        V2TokenCounts = 12
+        V2TokenCounts = 11
 
         SequencePair = Struct.new(:stream, :consumer)
 

data/lib/nats/io/jetstream/msg/ack_methods.rb

@@ -95,9 +95,9 @@ module NATS
           n = tokens.count
 
           if n < Ack::V1TokenCounts || ((n > Ack::V1TokenCounts) && (n < Ack::V2TokenCounts))
-            raise NotJSMessage.new("nats: not a jetstream message")
+            raise JetStream::Error::NotJSMessage.new("nats: not a jetstream message")
           elsif tokens[0] != Ack::Prefix0 || tokens[1] != Ack::Prefix1
-            raise NotJSMessage.new("nats: not a jetstream message")
+            raise JetStream::Error::NotJSMessage.new("nats: not a jetstream message")
           elsif n == Ack::V1TokenCounts
             tokens.insert(Ack::Domain, Ack::Empty)
             tokens.insert(Ack::AccHash, Ack::Empty)
@@ -105,6 +105,10 @@ module NATS
             tokens[Ack::Domain] = Ack::Empty
           end
 
+          unless Ack::NumericTokens.all? { |i| Ack::Digits.match?(tokens[i]) }
+            raise JetStream::Error::NotJSMessage.new("nats: not a jetstream message")
+          end
+
           Metadata.new(tokens)
         end
       end

data/lib/nats/io/jetstream/msg/metadata.rb

@@ -27,7 +27,8 @@ module NATS
           @domain = opts[Ack::Domain]
           @num_delivered = opts[Ack::NumDelivered].to_i
           @num_pending = opts[Ack::NumPending].to_i
-          @timestamp = Time.at((opts[Ack::Timestamp].to_i / 1_000_000_000.0))
+          nanos = opts[Ack::Timestamp].to_i
+          @timestamp = Time.at(nanos / 1_000_000_000, nanos % 1_000_000_000, :nsec)
           @stream = opts[Ack::Stream]
           @consumer = opts[Ack::Consumer]
           # TODO: Not exposed in Go client either right now.

data/lib/nats/io/jetstream.rb

@@ -305,7 +305,7 @@ module NATS
         # If attempting to bind, then this is a hard error.
         raise e if params[:stream] && !multi_filter
 
-        config = if !(params[:config])
+        config = if !params[:config]
           JetStream::API::ConsumerConfig.new
         elsif params[:config].is_a?(JetStream::API::ConsumerConfig)
           params[:config]

data/lib/nats/io/kv.rb

@@ -31,7 +31,7 @@ module NATS
     ROLLUP = "Nats-Rollup"
 
     VALID_BUCKET_RE = /\A[a-zA-Z0-9_-]+$/
-    VALID_KEY_RE = /\A[-\/_=\.a-zA-Z0-9]+$/
+    VALID_KEY_RE = /\A[-\/_=.a-zA-Z0-9]+$/
 
     class << self
       def is_valid_key(key)
@@ -273,7 +273,7 @@ module NATS
       nc = @js.nc
       watcher = KeyWatcher.new(@js)
 
-      deliver_policy = if !(params[:include_history])
+      deliver_policy = if !params[:include_history]
         "last_per_subject"
       end
 
@@ -327,15 +327,9 @@ module NATS
         meta = msg.metadata
         watcher.synchronize { watcher._active = true }
         # Track the sequences
-        #
-        # $JS.ACK.KV_TEST.CKRGrWpf.1.10.10.1739859923871837000.0
-        #
-        tokens = msg.reply.split(".")
-        sseq = tokens[5]
-        dseq = tokens[6]
         watcher.synchronize do
-          watcher._dseq = dseq.to_i + 1
-          watcher._sseq = sseq.to_i
+          watcher._dseq = meta.sequence.consumer + 1
+          watcher._sseq = meta.sequence.stream
         end
 
         # Keys() handling
@@ -465,6 +459,7 @@ module NATS
   class KeyWatcher
     include MonitorMixin
     include Enumerable
+
     attr_accessor :received, :pending, :_sub, :_updates, :_init_done, :_watcher_cond
     attr_accessor :_sseq, :_dseq, :_active, :_hb_task
 

data/lib/nats/io/parser.rb

@@ -17,7 +17,7 @@
 module NATS
   module Protocol
     MSG = /\AMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\r\n/i
-    HMSG = /\AHMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?([\d]+)\s+(\d+)\r\n/i
+    HMSG = /\AHMSG\s+([^\s]+)\s+([^\s]+)\s+(([^\s]+)[^\S\r\n]+)?(\d+)\s+(\d+)\r\n/i
     OK = /\A\+OK\s*\r\n/i
     ERR = /\A-ERR\s+('.+')?\r\n/i
     PING = /\APING\s*\r\n/i
@@ -98,12 +98,12 @@ module NATS
             return unless @needed && @buf.bytesize >= (@needed + CR_LF_SIZE)
             if @header_needed
               hbuf = @buf.slice(0, @header_needed)
-              payload = @buf.slice(@header_needed, (@needed - @header_needed))
+              payload = @buf.slice(@header_needed, @needed - @header_needed)
               @nc.send(:process_msg, @sub, @sid, @reply, payload, hbuf)
             else
               @nc.send(:process_msg, @sub, @sid, @reply, @buf.slice(0, @needed), nil)
             end
-            @buf = @buf.slice((@needed + CR_LF_SIZE), @buf.bytesize)
+            @buf = @buf.slice(@needed + CR_LF_SIZE, @buf.bytesize)
 
             @sub = @sid = @reply = @needed = @header_needed = nil
             @parse_state = AWAITING_CONTROL_LINE

data/lib/nats/io/subscription.rb

@@ -148,13 +148,20 @@ module NATS
         msg = pending_queue.pop(true)
         process(msg)
       rescue ThreadError # queue is empty
-        concurrency_semaphore.release
+        # No release here: the ensure below releases the permit; a second
+        # release would grow the semaphore beyond processing_concurrency.
       ensure
         concurrency_semaphore.release
         [concurrency_semaphore.available_permits, pending_queue.size].min.times do
           enqueue_processing(executor)
         end
       end
+    rescue Concurrent::RejectedExecutionError
+      # The executor is being shut down (the connection is closing,
+      # draining or reconnecting). Release the permit so the
+      # subscription can process messages again after a reconnect;
+      # the message stays in pending_queue.
+      concurrency_semaphore.release
     end
   end
 end

data/lib/nats/io/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright 2016-2025 The NATS Authors
+# Copyright 2016-2026 The NATS Authors
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -17,7 +17,7 @@
 module NATS
   module IO
     # VERSION is the version of the client announced on CONNECT to the server.
-    VERSION = "2.5.0"
+    VERSION = "2.6.0"
 
     # LANG is the lang runtime of the client announced on CONNECT to the server.
     LANG = "#{RUBY_ENGINE}#{RUBY_VERSION}".freeze

data/lib/nats/io/websocket.rb

@@ -47,23 +47,28 @@ module NATS
       end
 
       def read(max_bytes = MAX_SOCKET_READ_BYTES, deadline = nil)
-        data = super
-        @frame << data
-        result = []
-        while (msg = @frame.next)
-          result << msg
+        # Hand over what read_line decoded beyond its last line first,
+        # otherwise those bytes are lost once the read loop takes over.
+        if @line_buf && !@line_buf.empty?
+          return @line_buf.slice!(0, @line_buf.bytesize)
         end
-        result.join
+
+        read_frames(max_bytes, deadline)
       end
 
       def read_line(deadline = nil)
-        data = super
-        @frame << data
-        result = []
-        while (msg = @frame.next)
-          result << msg
+        @line_buf ||= +""
+        loop do
+          if (idx = @line_buf =~ /\r?\n/)
+            return @line_buf.slice!(0, idx + Regexp.last_match(0).length)
+          end
+
+          # Pull more data from the wire; never from @line_buf itself,
+          # or a partial line would be fed back forever.
+          data = read_frames(MAX_SOCKET_READ_BYTES, deadline)
+          return nil unless data
+          @line_buf << data
         end
-        result.join
       end
 
       def write(data, deadline = nil)
@@ -72,6 +77,21 @@ module NATS
         frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: :binary, version: @handshake.version)
         super(frame.to_s)
       end
+
+      private
+
+      # Reads from the socket and returns the payloads of all complete
+      # frames decoded so far.
+      def read_frames(max_bytes, deadline)
+        data = Socket.instance_method(:read).bind_call(self, max_bytes, deadline)
+        @frame << data
+        [].tap do |parts|
+          while (msg = @frame.next)
+            payload = msg.respond_to?(:data) ? msg.data : msg
+            parts << payload if payload
+          end
+        end.join
+      end
     end
   end
 end

data/lib/nats/service/validator.rb

@@ -6,8 +6,8 @@ module NATS
       REGEX = {
         name: /[A-Za-z0-9\-_]+$/,
         version: /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/,
-        subject: /^[^ >]*[>]?$/,
-        queue: /^[^ >]*[>]?$/
+        subject: /^[^ >]*>?$/,
+        queue: /^[^ >]*>?$/
       }.freeze
 
       class << self

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nats-pure
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Waldemar Quevedo
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -267,7 +266,6 @@ metadata:
   documentation_uri: https://github.com/nats-io/nats-pure.rb
   homepage_uri: https://github.com/nats-io/nats-pure.rb
   source_code_uri: https://github.com/nats-io/nats-pure.rb
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -282,8 +280,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 4.0.21
 specification_version: 4
 summary: NATS is an open-source, high-performance, lightweight cloud messaging system.
 test_files: []