nnq 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a336ac1e24bc6210ddeac6731163baab6f8980d9eebbe3235fac13157416fcf
-  data.tar.gz: f049bf9038235487966cae1c8920b452abf9984e3776b2b93cbbd95e067fb485
+  metadata.gz: 19bceda0339689e8850efe39120590002821f5c859eaf33e4ea1065af317bcaa
+  data.tar.gz: 2a15dd79b5cf4f8a41c564e89cf40af7296de8765e8e070de12057b4bc0dedf9
 SHA512:
-  metadata.gz: dcef45943a41f1bc53bbcf8ecc0c34c2779e4a16dea04e8f78854cf6a9debe11168596b47b764728e49393f61c319d41e2d79e489b37dec809adc59cbc0741f0
-  data.tar.gz: fd7aaa30c57d5b8fbfd6279aba8b96423e201837ca4ef0144a315ec020da5e0183aaede0c7327fc49bf1bd318894099e4fe02657a12aebf98c1d895582583c62
+  metadata.gz: 1e14a21e6d620df7770c27868f5fdb8ed945fb04137b8817c12fdaa2fdfca1e36a952e6fc4afc5be60562dfd1ff8f43d9d1781ce9a4fb6a1c3a8963cd3738233
+  data.tar.gz: 13aae01f03df0b0eca53aa0329d0f2d35b036b4f52744f83033cc46297eae39a60b2c639ad144c9ee3af63cee7d3780c3fff036d30f418e078ccb89253f70761

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.6.1 — 2026-04-15
+
+- **Verbose trace (`-vvv`) now fires for cooked REQ/REP/RESPONDENT
+  sends.** Cooked `Req#send_request`, `Rep#send_reply`, and
+  `Respondent#send_reply` bypass `send_pump` and write to the
+  connection directly, so they were never emitting `:message_sent`
+  monitor events — `-vvv` only ever showed the `<<` recv side. Each
+  now calls `emit_verbose_msg_sent(body)` after the write. Raw
+  REQ/REP/RESPONDENT sends get the same treatment (raw surveyor
+  already emitted via its per-peer send pump).
+- **Verbose recv previews strip the SP backtrace header.** The recv
+  loop used to emit the raw wire body, so `-vvv` traces for
+  REQ/REP/SURVEYOR/RESPONDENT showed the 4-byte request/survey id
+  (or a multi-word backtrace stack) in front of the payload. Routing
+  strategies now expose an optional `preview_body(wire)` hook; the
+  engine calls it before emitting `:message_received` so the trace
+  shows just the payload.
+- **`Engine#close` drains the monitor queue before cancelling
+  tasks.** The monitor consumer fiber lives under the socket-level
+  barrier, so `barrier.stop` used to `Async::Stop` it before it had
+  a chance to drain trailing events. `close` now emits `:closed`,
+  enqueues the nil sentinel, and awaits the stored `monitor_task`
+  before stopping the barrier. Fixes flaky `-vvv` traces on
+  short-lived sockets where the last `:message_received` event
+  would occasionally be lost.
+
 ## 0.6.0 — 2026-04-15
 
 - **NNG-style raw mode for REQ/REP and SURVEYOR/RESPONDENT.** Constructing

data/lib/nnq/engine.rb

@@ -70,6 +70,10 @@ module NNQ
     attr_accessor :monitor_queue
 
 
+    # @return [Async::Task, nil] the monitor consumer task, if any
+    attr_accessor :monitor_task
+
+
     # @return [Boolean] when true, {#emit_verbose_monitor_event} forwards
     #   per-message traces (:message_sent / :message_received) to the
     #   monitor queue. Set by {Socket#monitor} via its +verbose:+ kwarg.
@@ -286,6 +290,15 @@ module NNQ
       # collection mutates during iteration, so snapshot the values.
       @connections.values.each(&:close!)
 
+      # Emit :closed, seal the monitor queue, and wait for the monitor
+      # fiber to drain it before cancelling tasks. Without this join,
+      # trailing :message_received events that the recv pump enqueued
+      # just before close would be lost when the barrier.stop below
+      # Async::Stops the monitor fiber mid-dequeue.
+      emit_monitor_event(:closed)
+      close_monitor_queue
+      @monitor_task&.wait
+
       # Cascade-cancel every remaining task (reconnect loops, accept
       # loops, supervisors) in one shot.
       @lifecycle.barrier&.stop
@@ -295,8 +308,6 @@ module NNQ
       # Unblock anyone waiting on peer_connected when the socket is
       # closed before a peer ever arrived.
       @lifecycle.peer_connected.resolve(nil) unless @lifecycle.peer_connected.resolved?
-      emit_monitor_event(:closed)
-      close_monitor_queue
     end
 
 
@@ -337,7 +348,10 @@ module NNQ
       @connections[conn].barrier.async(annotation: "nnq recv #{conn.endpoint}") do
         loop do
           body = conn.receive_message
-          emit_verbose_msg_received(body)
+          if @verbose_monitor
+            preview = @routing.respond_to?(:preview_body) ? @routing.preview_body(body) : body
+            emit_verbose_msg_received(preview)
+          end
           @routing.enqueue(body, conn)
         rescue *CONNECTION_LOST, Async::Stop
           break

data/lib/nnq/routing/rep.rb

@@ -70,6 +70,14 @@ module NNQ
 
         return if conn.closed?
         conn.send_message(body, header: btrace)
+        @engine.emit_verbose_msg_sent(body)
+      end
+
+
+      # Strips the backtrace header for verbose trace previews.
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
       end
 
 

data/lib/nnq/routing/rep_raw.rb

@@ -36,11 +36,18 @@ module NNQ
         return if to.closed?
         return if Backtrace.too_many_hops?(header)
         to.send_message(body, header: header)
+        @engine.emit_verbose_msg_sent(body)
       rescue ClosedError
         # peer went away between receive and send — drop
       end
 
 
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
+      end
+
+
       # Called by the engine recv loop.
       def enqueue(wire_bytes, conn)
         header, payload = parse_backtrace(wire_bytes)

data/lib/nnq/routing/req.rb

@@ -56,6 +56,7 @@ module NNQ
         conn   = pick_peer
         header = [id].pack("N")
         conn.send_message(body, header: header)
+        @engine.emit_verbose_msg_sent(body)
         promise.wait
       ensure
         @mutex.synchronize do
@@ -81,6 +82,12 @@ module NNQ
       end
 
 
+      # Strips the 4-byte request id for verbose trace previews.
+      def preview_body(wire)
+        wire.byteslice(4..) || wire
+      end
+
+
       def close
         @mutex.synchronize do
           @outstanding&.last&.reject(NNQ::Error.new("REQ socket closed"))

data/lib/nnq/routing/req_raw.rb

@@ -26,6 +26,13 @@ module NNQ
       def send(body, header:)
         conn = pick_peer
         conn.send_message(body, header: header)
+        @engine.emit_verbose_msg_sent(body)
+      end
+
+
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
       end
 
 

data/lib/nnq/routing/respondent.rb

@@ -52,6 +52,14 @@ module NNQ
 
         return if conn.closed?
         conn.send_message(body, header: btrace)
+        @engine.emit_verbose_msg_sent(body)
+      end
+
+
+      # Strips the backtrace header for verbose trace previews.
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
       end
 
 

data/lib/nnq/routing/respondent_raw.rb

@@ -29,10 +29,17 @@ module NNQ
         return if to.closed?
         return if Backtrace.too_many_hops?(header)
         to.send_message(body, header: header)
+        @engine.emit_verbose_msg_sent(body)
       rescue ClosedError
       end
 
 
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
+      end
+
+
       def enqueue(wire_bytes, conn)
         header, payload = parse_backtrace(wire_bytes)
         return unless header

data/lib/nnq/routing/surveyor.rb

@@ -78,6 +78,12 @@ module NNQ
       end
 
 
+      # Strips the 4-byte survey id for verbose trace previews.
+      def preview_body(wire)
+        wire.byteslice(4..) || wire
+      end
+
+
       def connection_added(conn)
         queue             = Async::LimitedQueue.new(@engine.options.send_hwm)
         @queues[conn]     = queue

data/lib/nnq/routing/surveyor_raw.rb

@@ -47,6 +47,12 @@ module NNQ
       end
 
 
+      def preview_body(wire)
+        _, payload = parse_backtrace(wire)
+        payload || wire
+      end
+
+
       def connection_added(conn)
         queue             = Async::LimitedQueue.new(@engine.options.send_hwm)
         @queues[conn]     = queue

data/lib/nnq/socket.rb

@@ -126,13 +126,14 @@ module NNQ
       @engine.verbose_monitor = verbose
 
       Reactor.run do
-        @engine.spawn_task(annotation: "nnq monitor") do
+        @engine.monitor_task = @engine.spawn_task(annotation: "nnq monitor") do
           while (event = queue.dequeue)
             block.call(event)
           end
         rescue Async::Stop
         ensure
           @engine.monitor_queue = nil
+          @engine.monitor_task  = nil
           block.call(MonitorEvent.new(type: :monitor_stopped))
         end
       end

data/lib/nnq/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nnq
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Patrik Wenger