omq 0.19.0 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f01c18a7a887e0f2811abff2251f1b2c9b201091e800248fb852b92bedbcaf06
-  data.tar.gz: d32b3e07223d906a3bb25fc8542409bb5c05af36b509f7fe70c91419d0836cf9
+  metadata.gz: 19b283aa20e543617cd7be9c899d2954c219631fd57417536be4fb26798e6e85
+  data.tar.gz: a39d1c870e6171726a00a5f1809556e3ce7c3a8c0e4b0e84722eae15f83f93b6
 SHA512:
-  metadata.gz: c0b26ad39e26fe586cec53371bc4b1beeaf357b51f32e90ad8d889a8413f62c08c13be2d8f787e3528d4fca6bccc1ceae21454474465aff25f9418c37460d957
-  data.tar.gz: b8d3acedee187c9c757268af173b55bd28daf502f8e054f92ef670c59a1781e2b2f73267425c239d27acc7cb036b0030ab562a12918c7db205dc34f4bcf8e38d
+  metadata.gz: 7a020d02b2a1da25dd37f6ff92836348985fb7bcd7b8c17392bacb4c23d0ee443b2dd294f8e30d5df5724e11049462d428efb6d2b5a3313b479ab7a3e7e71388
+  data.tar.gz: 3b9724342594f22aabe00d1b13d7aa71bfe652ca21954c6b4789556e95743fd03d1c62214a164be8cad717405766a5d0acdbb4c3fd73a0f95aa14738cfb17d81

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.19.2 — 2026-04-13
+
+### Added
+
+- **`:disconnected` monitor events carry the underlying error.** When
+  a connection drops due to a `Protocol::ZMTP::Error` (oversized
+  frame, bad framing, zstd bytebomb, nonce exhaustion, …) or a
+  `CONNECTION_LOST` error, the `:disconnected` event's `detail` hash
+  now includes `error:` (the exception instance) and `reason:` (its
+  message). Peer tooling can match on `detail[:error].is_a?(...)` to
+  enforce its own policy — e.g. `omq-cli` terminates the command on
+  `Protocol::ZMTP::Error`, while the library keeps the libzmq-parity
+  behavior of silently dropping the offending connection and
+  reconnecting.
+- **`OMQ::Socket#engine` public reader.** The socket's engine is now
+  a documented (if low-level) accessor for peer tooling that needs
+  to reach into internals — notably so `omq-cli`'s monitor callback
+  can call `sock.engine.signal_fatal_error(error)` without
+  `instance_variable_get`. Not part of the stable user API.
+
+### Fixed
+
+- **`signal_fatal_error` preserves the underlying cause.** The
+  resulting `SocketDeadError` now chains back to the original error
+  via `Exception#cause` regardless of whether `signal_fatal_error`
+  is called from inside a rescue block or from a monitor callback
+  (where `$!` is `nil`). Uses a raise-in-rescue helper to force the
+  cause chain. The wrapped error's message also includes the
+  original reason so tooling that only logs the top-level message
+  still shows what happened.
+
+## 0.19.1 — 2026-04-13
+
+### Fixed
+
+- **Send-queue batch accounting tolerates non-string parts.**
+  `Routing::RoundRobin#drain_send_queue_capped` previously called
+  `#bytesize` directly on each message part for the fairness cap, which
+  crashed when a connection wrapper enqueued structured parts for later
+  transformation (notably `OMQ::Ractor`'s `MarshalConnection`, which
+  hands off live Ruby objects and marshals them in `#write_messages`).
+  The fairness cap now skips parts that don't respond to `#bytesize`.
+
 ## 0.19.0 — 2026-04-12
 
 ### Added

data/lib/omq/engine/connection_lifecycle.rb

@@ -133,8 +133,18 @@ module OMQ
       # routing removal, monitor event, reconnect scheduling.
       # Idempotent: a no-op if already :closed.
       #
-      def lost!
-        tear_down!(reconnect: true)
+      def lost!(reason: nil)
+        tear_down!(reconnect: true, reason: reason || @disconnect_reason)
+      end
+
+
+      # Records the exception that took down a pump task so that the
+      # supervisor can surface it in the :disconnected monitor event.
+      # First writer wins — subsequent pumps unwinding on the same
+      # teardown don't overwrite the original cause.
+      #
+      def record_disconnect_reason(error)
+        @disconnect_reason ||= error
       end
 
 
@@ -187,21 +197,20 @@ module OMQ
           end
         rescue Async::Stop, Async::Cancel
           # socket or supervisor cancelled externally (socket closing)
-        rescue Protocol::ZMTP::Error, *CONNECTION_LOST
-          # expected pump exit on disconnect
         ensure
           lost!
         end
       end
 
 
-      def tear_down!(reconnect:)
+      def tear_down!(reconnect:, reason: nil)
         return if @state == :closed
         transition!(:closed)
         @engine.connections.delete(@conn)
         @engine.routing.connection_removed(@conn) if @conn
         @conn&.close rescue nil
-        @engine.emit_monitor_event(:disconnected, endpoint: @endpoint)
+        detail = reason ? { error: reason, reason: reason.message } : nil
+        @engine.emit_monitor_event(:disconnected, endpoint: @endpoint, detail: detail)
         @done&.resolve(true)
         @engine.resolve_all_peers_gone_if_empty
         @engine.maybe_reconnect(@endpoint) if reconnect

data/lib/omq/engine/recv_pump.rb

@@ -106,10 +106,12 @@ module OMQ
             task.yield
           end
         rescue Async::Stop, Async::Cancel
-        rescue Protocol::ZMTP::Error, *CONNECTION_LOST
-          # expected disconnect — supervisor will trigger teardown
+        rescue Protocol::ZMTP::Error, *CONNECTION_LOST => error
+          # expected disconnect — stash reason for the :disconnected
+          # monitor event, let the lifecycle reconnect as usual
+          engine.connections[conn]&.record_disconnect_reason(error)
         rescue => error
-          @engine.signal_fatal_error(error)
+          engine.signal_fatal_error(error)
         end
       end
 
@@ -136,10 +138,12 @@ module OMQ
             task.yield
           end
         rescue Async::Stop, Async::Cancel
-        rescue Protocol::ZMTP::Error, *CONNECTION_LOST
-          # expected disconnect — supervisor will trigger teardown
+        rescue Protocol::ZMTP::Error, *CONNECTION_LOST => error
+          # expected disconnect — stash reason for the :disconnected
+          # monitor event, let the lifecycle reconnect as usual
+          engine.connections[conn]&.record_disconnect_reason(error)
         rescue => error
-          @engine.signal_fatal_error(error)
+          engine.signal_fatal_error(error)
         end
       end
 

data/lib/omq/engine.rb

@@ -386,8 +386,12 @@ module OMQ
 
       lifecycle.barrier.async(transient: true, annotation: annotation) do
         yield
-      rescue Async::Stop, Async::Cancel, Protocol::ZMTP::Error, *CONNECTION_LOST
-        # normal shutdown / expected disconnect / sibling tore us down
+      rescue Async::Stop, Async::Cancel
+        # normal shutdown / sibling tore us down
+      rescue Protocol::ZMTP::Error, *CONNECTION_LOST => error
+        # expected disconnect — stash reason for the :disconnected
+        # monitor event, then let the lifecycle reconnect as usual
+        lifecycle.record_disconnect_reason(error)
       rescue => error
         signal_fatal_error(error)
       end
@@ -395,25 +399,35 @@ module OMQ
 
 
     # Wraps an unexpected pump error as {OMQ::SocketDeadError} and
-    # unblocks any callers waiting on the recv queue.
-    #
-    # Must be called from inside a rescue block so that +error+ is
-    # +$!+ and Ruby sets it as +#cause+ on the new exception.
+    # unblocks any callers waiting on the recv queue. The original
+    # error is preserved as +#cause+ so callers can surface the real
+    # reason.
     #
     # @param error [Exception]
     #
     def signal_fatal_error(error)
       return unless @lifecycle.open?
-      @fatal_error = begin
-        raise SocketDeadError, "internal error killed #{@socket_type} socket"
-      rescue => wrapped
-        wrapped
-      end
+      @fatal_error = build_fatal_error(error)
       routing.recv_queue.push(nil) rescue nil
       @lifecycle.peer_connected.resolve(nil) rescue nil
     end
 
 
+    # Constructs a SocketDeadError whose +cause+ is +error+. Uses the
+    # raise-in-rescue idiom because Ruby only sets +cause+ on an
+    # exception when it is raised from inside a rescue block -- works
+    # regardless of the original caller's +$!+ state.
+    def build_fatal_error(error)
+      raise error
+    rescue
+      begin
+        raise SocketDeadError, "#{@socket_type} socket killed: #{error.message}"
+      rescue SocketDeadError => wrapped
+        wrapped
+      end
+    end
+
+
     # Captures the socket's task tree root and starts the socket-level
     # maintenance task. If +parent+ is given, it is used as the parent
     # for every task spawned under this socket (connection supervisors,

data/lib/omq/routing/round_robin.rb

@@ -147,16 +147,26 @@ module OMQ
       BATCH_BYTE_CAP = 512 * 1024
 
       def drain_send_queue_capped(batch)
-        bytes = batch[0].sum(&:bytesize)
+        bytes = batch_bytes(batch[0])
         while batch.size < BATCH_MSG_CAP && bytes < BATCH_BYTE_CAP
           msg = @send_queue.dequeue(timeout: 0)
           break unless msg
           batch << msg
-          bytes += msg.sum(&:bytesize)
+          bytes += batch_bytes(msg)
         end
       end
 
 
+      # Byte accounting for send-queue batching. Connection wrappers
+      # (e.g. OMQ::Ractor's MarshalConnection) may enqueue non-string
+      # parts that get transformed at write time — skip those for the
+      # fairness cap rather than crashing on #bytesize.
+      #
+      def batch_bytes(parts)
+        parts.sum { |p| p.respond_to?(:bytesize) ? p.bytesize : 0 }
+      end
+
+
       def write_batch(conn, batch)
         if batch.size == 1
           conn.send_message(transform_send(batch[0]))

data/lib/omq/socket.rb

@@ -16,6 +16,13 @@ module OMQ
     attr_reader :last_tcp_port
 
 
+    # @return [Engine] the socket's engine. Exposed for peer tooling
+    #   (omq-cli, omq-ffi, omq-ractor) that needs to reach into the
+    #   socket's internals — not part of the stable user API.
+    #
+    attr_reader :engine
+
+
     # Delegate socket option accessors to @options.
     #
     extend Forwardable

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.19.0"
+  VERSION = "0.19.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.2
 platform: ruby
 authors:
 - Patrik Wenger