omq 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 851ef7f69ffe66641f2bd7ada2afdd0429867b9c518451b91c0ba0ea87706579
-  data.tar.gz: 8ae83e9074fb824907dd9b25f2826c895d7ed0541e55a0d3efa45266ab34461a
+  metadata.gz: 20e7575603dbe5f8f68e141aa0038a9e2cf7c14e31d9da0d760d7a2b13c99ab6
+  data.tar.gz: 0a0b985e79f73a47a30576ed076aca0b4a2eb59b8caee7b264a2afa54c314c54
 SHA512:
-  metadata.gz: '096166f698305a29706aebf68a3d22eb28565972cd04fbfe705ca01c63d153a2b0200c50b6d9e7d3a22dfbcb9c721f08372a6f8ffed13649dcab3396587aa330'
-  data.tar.gz: b7adf1b1f0a6b1d8f2beb6156174770e893ac03eb36d705a94c002011906e891f634527c53f7c44a2ce9176d95335a1845cbad63da5a97d0428252292213cf44
+  metadata.gz: 6580a6dbc766bfc737616bbcf427c05b0505fddcc167d37739b6c7750505749a955bd6df5c070126f4e8cfde60abe03a23549e5f179d4d4aa1dee370d7de5716
+  data.tar.gz: 73a81ef7e80ea2589dfb11502927369ca0dbffbeecfc867a4c5ce6c3d850ef413028be832e30615ae3b7f3983c611c8dfd3693e076b78f527f8abcff624b520a

data/CHANGELOG.md

@@ -1,7 +1,61 @@
 # Changelog
 
+## 0.15.0 — 2026-04-07
+
+- **Fix pipe FIFO ordering** — messages from sequential source batches could
+  interleave when a connection dropped and reconnected. `FairQueue` now moves
+  orphaned per-connection queues to a priority drain list, ensuring all buffered
+  messages from a disconnected peer are consumed before any new peer's messages.
+- **Fix lost messages on disconnect** — `RoundRobin#remove_round_robin_send_connection`
+  now drains the per-connection send queue back to staging before closing it, and
+  the send pump re-stages its in-flight batch on `CONNECTION_LOST`. Previously
+  messages in the per-connection queue or mid-batch were silently dropped.
+- **Fix `next_connection` deadlock** — when the round-robin cycle exhausted with
+  connections still present, a new unresolved `Async::Promise` was created
+  unconditionally, blocking the sender forever. Now only creates a new promise
+  when `@connections` is actually empty.
+- **Fix staging drain race** — `add_round_robin_send_connection` now appends to
+  `@connections` after draining staging (not before), preventing the pipe loop
+  from bypassing staging during drain. A second drain pass catches any message
+  that squeezed in during the first.
+- **Fix `handshake_succeeded` event ordering** — the monitor event is now emitted
+  before `connection_added` (which may yield during drain), so it always appears
+  before any `message_sent` events on that connection.
+- **Fix send pump `Async::Stop` preventing reconnect** — `remove_round_robin_send_connection`
+  no longer calls `task.stop` on the send pump. Instead it closes the queue and
+  lets the pump detect nil, avoiding `Async::Stop` propagation that prevented
+  `maybe_reconnect` from running.
+- **Add `StagingQueue`** — bounded FIFO queue with `#prepend` for re-staging
+  failed messages at the front. Replaces raw `Async::LimitedQueue` in
+  `RoundRobin` and `Pair` routing strategies.
+- **Add `SingleFrame` mixin to core** — moved from 5 duplicate copies across
+  RFC gems to `OMQ::SingleFrame`, eliminating method redefinition warnings.
+- **Add `SO_SNDBUF` / `SO_RCVBUF` socket options** — `Options#sndbuf` and
+  `Options#rcvbuf` set kernel buffer sizes on TCP and IPC sockets (both
+  accepted and connected).
+- **Add verbose monitor events** — `Socket#monitor(verbose: true)` emits
+  `:message_sent` and `:message_received` events via `Engine#emit_verbose_monitor_event`.
+  Allocation-free when verbose is off.
+- **Add `OMQ::DEBUG` flag** — when `OMQ_DEBUG` is set, transport accept loops
+  print unexpected exceptions to stderr.
+- **Fix `Pair` re-staging on disconnect** — `Pair#connection_removed` now drains
+  the per-connection send queue back to staging, and the send pump re-stages its
+  batch on `CONNECTION_LOST`.
+
 ## 0.14.1 — 2026-04-07
 
+- **Fix PUSH send queue deadlock on disconnect** — when a peer disconnected
+  while a fiber was blocked on a full per-connection send queue (low `send_hwm`),
+  the fiber hung forever. Now closes the queue on disconnect, raising
+  `ClosedError` which re-routes the message to staging. Also reorders
+  `add_round_robin_send_connection` to start the send pump before draining
+  staging, preventing deadlock with small queues.
+- **Fix reconnect backoff for plain Numeric** — `#next_delay` incorrectly
+  doubled the delay even when `reconnect_interval` was a plain Numeric. Now
+  only Range triggers exponential backoff; a fixed Numeric returns the same
+  interval every retry.
+- **Default `reconnect_interval` changed to `0.1..1.0`** — uses exponential
+  backoff (100 ms → 1 s cap) by default instead of a fixed 100 ms.
 - **Fix per-connection task tree** — recv pump, heartbeat, and reaper tasks
   were spawned under `@parent_task` (socket-level) instead of the connection
   task. When `@parent_task` finished before a late connection completed its

data/lib/omq/engine/connection_setup.rb

@@ -37,8 +37,8 @@ module OMQ
         conn.handshake!
         Heartbeat.start(Async::Task.current, conn, @engine.options, @engine.tasks)
         conn = @engine.connection_wrapper.call(conn) if @engine.connection_wrapper
-        register(conn, endpoint, done)
         @engine.emit_monitor_event(:handshake_succeeded, endpoint: endpoint)
+        register(conn, endpoint, done)
         conn
       rescue Protocol::ZMTP::Error, *CONNECTION_LOST => error
         @engine.emit_monitor_event(:handshake_failed, endpoint: endpoint, detail: { error: error })

data/lib/omq/engine/reconnect.rb

@@ -71,11 +71,15 @@ module OMQ
 
 
       def next_delay(delay, max_delay)
-        ri    = @options.reconnect_interval
-        delay = delay * 2
-        delay = [delay, max_delay].min if max_delay
-        delay = (ri.is_a?(Range) ? ri.begin : ri) if delay == 0
-        delay
+        ri = @options.reconnect_interval
+        if ri.is_a?(Range)
+          delay = delay * 2
+          delay = [delay, max_delay].min if max_delay
+          delay = ri.begin if delay == 0
+          delay
+        else
+          ri
+        end
       end
     end
   end

data/lib/omq/engine/recv_pump.rb

@@ -68,7 +68,7 @@ module OMQ
 
 
       def start_with_transform(parent_task, transform)
-        conn, recv_queue, count_bytes = @conn, @recv_queue, @count_bytes
+        conn, recv_queue, engine, count_bytes = @conn, @recv_queue, @engine, @count_bytes
 
         parent_task.async(transient: true, annotation: "recv pump") do |task|
           loop do
@@ -78,6 +78,7 @@ module OMQ
               msg = conn.receive_message
               msg = transform.call(msg).freeze
               recv_queue.enqueue(msg)
+              engine.emit_verbose_monitor_event(:message_received, parts: msg)
               count += 1
               bytes += msg.sum(&:bytesize) if count_bytes
             end
@@ -93,7 +94,7 @@ module OMQ
 
 
       def start_direct(parent_task)
-        conn, recv_queue, count_bytes = @conn, @recv_queue, @count_bytes
+        conn, recv_queue, engine, count_bytes = @conn, @recv_queue, @engine, @count_bytes
 
         parent_task.async(transient: true, annotation: "recv pump") do |task|
           loop do
@@ -102,6 +103,7 @@ module OMQ
             while count < FAIRNESS_MESSAGES && bytes < FAIRNESS_BYTES
               msg = conn.receive_message
               recv_queue.enqueue(msg)
+              engine.emit_verbose_monitor_event(:message_received, parts: msg)
               count += 1
               bytes += msg.sum(&:bytesize) if count_bytes
             end

data/lib/omq/engine.rb

@@ -78,6 +78,7 @@ module OMQ
       @on_io_thread      = false
       @fatal_error       = nil
       @monitor_queue     = nil
+      @verbose_monitor   = false
     end
 
 
@@ -95,6 +96,7 @@ module OMQ
     #   @param value [Async::Queue, nil] queue for monitor events
     #
     attr_writer :reconnect_enabled, :monitor_queue
+    attr_accessor :verbose_monitor
 
     # @return [Boolean] true if the engine has been closed
     #
@@ -222,9 +224,9 @@ module OMQ
     def connection_ready(pipe, endpoint: nil)
       pipe = @connection_wrapper.call(pipe) if @connection_wrapper
       @connections[pipe] = ConnectionRecord.new(endpoint: endpoint, done: nil)
+      emit_monitor_event(:handshake_succeeded, endpoint: endpoint)
       @routing.connection_added(pipe)
       @peer_connected.resolve(pipe)
-      emit_monitor_event(:handshake_succeeded, endpoint: endpoint)
     end
 
 
@@ -404,6 +406,20 @@ module OMQ
     end
 
 
+    # Emits a verbose-only monitor event (e.g. message traces).
+    # Only emitted when {Socket#monitor} was called with +verbose: true+.
+    # Uses +**detail+ to avoid Hash allocation when verbose is off.
+    #
+    # @param type [Symbol] event type (e.g. :message_sent, :message_received)
+    # @param detail [Hash] extra context forwarded as keyword args
+    # @return [void]
+    #
+    def emit_verbose_monitor_event(type, **detail)
+      return unless @verbose_monitor
+      emit_monitor_event(type, detail: detail)
+    end
+
+
     # Looks up the transport module for an endpoint URI.
     #
     # @param endpoint [String] endpoint URI (e.g. "tcp://...", "inproc://...")
@@ -423,6 +439,8 @@ module OMQ
         done = Async::Promise.new
         conn = ConnectionSetup.run(io, self, as_server: as_server, endpoint: endpoint, done: done)
         done.wait
+      rescue Async::Queue::ClosedError
+        # connection dropped during drain — message re-staged
       rescue Protocol::ZMTP::Error, *CONNECTION_LOST
         # handshake failed or connection lost — subtree cleaned up
       ensure

data/lib/omq/options.rb

@@ -20,12 +20,14 @@ module OMQ
       @router_mandatory      = false
       @read_timeout          = nil   # seconds, nil = no timeout
       @write_timeout         = nil
-      @reconnect_interval    = 0.1   # seconds, or Range for backoff (e.g. 0.1..5.0)
+      @reconnect_interval    = 0.1..1.0  # seconds; Range sets backoff min..max
       @heartbeat_interval    = nil   # seconds, nil = disabled
       @heartbeat_ttl         = nil   # seconds, nil = use heartbeat_interval
       @heartbeat_timeout     = nil   # seconds, nil = use heartbeat_interval
       @max_message_size      = 1 << 20  # bytes (1 MiB default)
       @conflate              = false
+      @sndbuf                = nil   # bytes, nil = OS default
+      @rcvbuf                = nil   # bytes, nil = OS default
       @on_mute               = :block   # :block, :drop_newest, :drop_oldest
       @mechanism             = Protocol::ZMTP::Mechanism::Null.new
       @qos                   = 0       # 0 = fire-and-forget, 1 = at-least-once (see omq-qos gem)
@@ -58,6 +60,10 @@ module OMQ
     #   @return [Numeric, nil] time without traffic before closing (nil = use heartbeat_interval)
     # @!attribute max_message_size
     #   @return [Integer, nil] maximum message size in bytes
+    # @!attribute sndbuf
+    #   @return [Integer, nil] SO_SNDBUF size in bytes (nil = OS default)
+    # @!attribute rcvbuf
+    #   @return [Integer, nil] SO_RCVBUF size in bytes (nil = OS default)
     # @!attribute on_mute
     #   @return [Symbol] mute strategy (:block, :drop_newest, :drop_oldest)
     # @!attribute mechanism
@@ -72,6 +78,7 @@ module OMQ
                   :reconnect_interval,
                   :heartbeat_interval,    :heartbeat_ttl,    :heartbeat_timeout,
                   :max_message_size,
+                  :sndbuf,    :rcvbuf,
                   :on_mute,
                   :mechanism,
                   :qos

data/lib/omq/routing/conn_send_pump.rb

@@ -23,6 +23,7 @@ module OMQ
             Routing.drain_send_queue(q, batch)
             batch.each { |parts| conn.write_message(parts) }
             conn.flush
+            batch.each { |parts| engine.emit_verbose_monitor_event(:message_sent, parts: parts) }
           rescue Protocol::ZMTP::Error, *CONNECTION_LOST
             engine.connection_lost(conn)
             break

data/lib/omq/routing/dealer.rb

@@ -27,7 +27,6 @@ module OMQ
       # @param connection [Connection]
       #
       def connection_added(connection)
-        @connections << connection
         add_fair_recv_connection(connection)
         add_round_robin_send_connection(connection)
       end

data/lib/omq/routing/fair_queue.rb

@@ -16,6 +16,7 @@ module OMQ
       #
       def initialize
         @queues    = []              # ordered list of per-connection inner queues
+        @drain     = []              # orphaned queues, drained before active queues
         @mapping   = {}              # connection => inner queue
         @cycle     = @queues.cycle  # live reference — sees adds/removes
         @condition = Async::Condition.new
@@ -37,18 +38,18 @@ module OMQ
 
       # Removes the per-connection queue for a disconnected peer.
       #
-      # If the queue is empty it is removed immediately. If it still has
-      # pending messages it is kept in @queues so the application can drain
-      # them via #dequeue; it will be cleaned up lazily by try_dequeue once
-      # it is empty.
+      # If the queue still has pending messages it moves to the
+      # priority drain list so those messages are consumed before
+      # any active connection's messages — preserving FIFO for
+      # sequential connections.
       #
       # @param conn [Connection]
       #
       def remove_queue(conn)
         q = @mapping.delete(conn)
         return unless q
-        @queues.delete(q) if q.empty?
-        # Non-empty orphaned queues stay in @queues until drained
+        @queues.delete(q)
+        @drain << q unless q.empty?
       end
 
 
@@ -73,7 +74,7 @@ module OMQ
         return try_dequeue if timeout == 0
 
         loop do
-          return nil if @closed && @queues.all?(&:empty?)
+          return nil if @closed && @drain.empty? && @queues.all?(&:empty?)
 
           msg = try_dequeue
           return msg if msg
@@ -100,17 +101,25 @@ module OMQ
       # @return [Boolean]
       #
       def empty?
-        @queues.all?(&:empty?)
+        @drain.empty? && @queues.all?(&:empty?)
       end
 
       private
 
-      # Tries each per-connection queue once in round-robin order.
-      # Returns the first message found, or nil if all are empty.
-      # Lazily removes empty orphaned queues (disconnected peers that have
-      # been fully drained).
+      # Drains orphaned queues first (preserves FIFO for disconnected
+      # peers), then tries each active queue once in round-robin order.
       #
       def try_dequeue
+        # Priority: drain orphaned queues before serving active ones
+        until @drain.empty?
+          msg = @drain.first.dequeue(timeout: 0)
+          if msg
+            return msg
+          else
+            @drain.shift
+          end
+        end
+
         @queues.size.times do
           q = begin
                 @cycle.next
@@ -120,10 +129,6 @@ module OMQ
               end
           msg = q.dequeue(timeout: 0)
           return msg if msg
-          if q.empty? && !@mapping.value?(q)
-            @queues.delete(q)
-            break
-          end
         end
         nil
       end

data/lib/omq/routing/fan_out.rb

@@ -162,7 +162,10 @@ module OMQ
           loop do
             batch = [q.dequeue]
             Routing.drain_send_queue(q, batch)
-            conn.flush if write_matching_batch(conn, batch, use_wire)
+            if write_matching_batch(conn, batch, use_wire)
+              conn.flush
+              batch.each { |parts| @engine.emit_verbose_monitor_event(:message_sent, parts: parts) }
+            end
           rescue Protocol::ZMTP::Error, *CONNECTION_LOST
             @engine.connection_lost(conn)
             break
@@ -193,6 +196,7 @@ module OMQ
             begin
               conn.write_message(latest)
               conn.flush
+              @engine.emit_verbose_monitor_event(:message_sent, parts: latest)
             rescue Protocol::ZMTP::Error, *CONNECTION_LOST
               @engine.connection_lost(conn)
               break

data/lib/omq/routing/pair.rb

@@ -18,7 +18,7 @@ module OMQ
         @connection     = nil
         @recv_queue     = FairQueue.new
         @send_queue     = nil   # created per-connection
-        @staging_queue  = Routing.build_queue(@engine.options.send_hwm, :block)
+        @staging_queue  = StagingQueue.new(@engine.options.send_hwm)
         @send_pump      = nil
         @tasks          = []
       end
@@ -39,7 +39,7 @@ module OMQ
 
         unless connection.is_a?(Transport::Inproc::DirectPipe)
           @send_queue = Routing.build_queue(@engine.options.send_hwm, :block)
-          while (msg = @staging_queue.dequeue(timeout: 0))
+          while (msg = @staging_queue.dequeue)
             @send_queue.enqueue(msg)
           end
           start_send_pump(connection)
@@ -53,7 +53,12 @@ module OMQ
         if @connection == connection
           @connection = nil
           @recv_queue.remove_queue(connection)
-          @send_queue = nil
+          if @send_queue
+            while (msg = @send_queue.dequeue(timeout: 0))
+              @staging_queue.prepend(msg)
+            end
+            @send_queue = nil
+          end
           @send_pump&.stop
           @send_pump = nil
         end
@@ -100,7 +105,9 @@ module OMQ
             begin
               batch.each { |parts| conn.write_message(parts) }
               conn.flush
+              batch.each { |parts| @engine.emit_verbose_monitor_event(:message_sent, parts: parts) }
             rescue Protocol::ZMTP::Error, *CONNECTION_LOST
+              batch.each { |parts| @staging_queue.prepend(parts) }
               @engine.connection_lost(conn)
               break
             end

data/lib/omq/routing/push.rb

@@ -26,7 +26,6 @@ module OMQ
       # @param connection [Connection]
       #
       def connection_added(connection)
-        @connections << connection
         add_round_robin_send_connection(connection)
         start_reaper(connection)
       end

data/lib/omq/routing/req.rb

@@ -29,7 +29,6 @@ module OMQ
       # @param connection [Connection]
       #
       def connection_added(connection)
-        @connections << connection
         add_fair_recv_connection(connection) do |msg|
           @state = :ready
           msg.first&.empty? ? msg[1..] : msg

data/lib/omq/routing/round_robin.rb

@@ -35,7 +35,7 @@ module OMQ
         @conn_queues          = {}  # connection => send queue
         @conn_send_tasks      = {}  # connection => send pump task
         @direct_pipe          = nil
-        @staging_queue        = Routing.build_queue(@engine.options.send_hwm, :block)
+        @staging_queue        = StagingQueue.new(@engine.options.send_hwm)
       end
 
 
@@ -45,11 +45,18 @@ module OMQ
       # @param conn [Connection]
       #
       def add_round_robin_send_connection(conn)
-        update_direct_pipe
         q = Routing.build_queue(@engine.options.send_hwm, :block)
         @conn_queues[conn] = q
-        drain_staging_to(q)
         start_conn_send_pump(conn, q)
+        drain_staging_to(q)
+        @connections << conn
+        update_direct_pipe
+        # A message may have squeezed into staging while drain was
+        # running (the pipe loop's blocked enqueue completed after
+        # drain freed space).  Now that @connections is set, no new
+        # messages will go to staging, so this second drain is
+        # guaranteed to finish quickly.
+        drain_staging_to(q)
         signal_connection_available
       end
 
@@ -61,8 +68,14 @@ module OMQ
       #
       def remove_round_robin_send_connection(conn)
         update_direct_pipe
-        @conn_queues.delete(conn)
-        @conn_send_tasks.delete(conn)&.stop
+        q = @conn_queues.delete(conn)
+        if q
+          while (msg = q.dequeue(timeout: 0))
+            @staging_queue.prepend(msg)
+          end
+          q.close
+        end
+        @conn_send_tasks.delete(conn)
       end
 
 
@@ -105,6 +118,8 @@ module OMQ
           conn = next_connection
           @conn_queues[conn].enqueue(parts)
         end
+      rescue Async::Queue::ClosedError
+        retry
       end
 
 
@@ -113,9 +128,13 @@ module OMQ
       # were enqueued before any connection existed.
       #
       def drain_staging_to(q)
-        while (msg = @staging_queue.dequeue(timeout: 0))
+        while (msg = @staging_queue.dequeue)
           q.enqueue(msg)
         end
+      rescue Async::Queue::ClosedError
+        # Connection dropped while draining — put the undelivered
+        # message back at the front so ordering is preserved.
+        @staging_queue.prepend(msg) if msg
       end
 
 
@@ -127,8 +146,10 @@ module OMQ
       def next_connection
         @cycle.next
       rescue StopIteration
-        @connection_available = Async::Promise.new
-        @connection_available.wait
+        if @connections.empty?
+          @connection_available = Async::Promise.new
+          @connection_available.wait
+        end
         @cycle = @connections.cycle
         retry
       end
@@ -153,10 +174,14 @@ module OMQ
       def start_conn_send_pump(conn, q)
         task = @engine.spawn_pump_task(annotation: "send pump") do
           loop do
-            batch = [q.dequeue]
+            msg = q.dequeue
+            break unless msg  # queue closed by remove_round_robin_send_connection
+            batch = [msg]
             Routing.drain_send_queue(q, batch)
             write_batch(conn, batch)
+            batch.each { |parts| @engine.emit_verbose_monitor_event(:message_sent, parts: parts) }
           rescue Protocol::ZMTP::Error, *CONNECTION_LOST
+            batch&.each { |parts| @staging_queue.prepend(parts) }
             @engine.connection_lost(conn)
             break
           end

data/lib/omq/routing/staging_queue.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Routing
+    # Bounded FIFO queue for staging unsent messages.
+    #
+    # Wraps an +Async::LimitedQueue+ for backpressure, with a small
+    # prepend buffer checked first on dequeue (same trick as the
+    # prefetch buffer in {OMQ::Readable#receive}).
+    #
+    class StagingQueue
+      # @param max [Integer, nil] capacity (nil or 0 = unbounded)
+      #
+      def initialize(max = nil)
+        @queue = (max && max > 0) ? Async::LimitedQueue.new(max) : Async::Queue.new
+        @head  = []
+        @mu    = Mutex.new
+      end
+
+
+      # Appends a message to the back.
+      # Blocks (fiber-yields) when at capacity.
+      #
+      # @param msg [Array<String>]
+      # @return [void]
+      #
+      def enqueue(msg)
+        @queue.enqueue(msg)
+      end
+
+
+      # Inserts a message at the front (for re-staging after a
+      # failed drain).
+      #
+      # @param msg [Array<String>]
+      # @return [void]
+      #
+      def prepend(msg)
+        @mu.synchronize { @head.push(msg) }
+      end
+
+
+      # Returns the first message: from the prepend buffer if
+      # non-empty, otherwise non-blocking dequeue from the main queue.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue
+        @mu.synchronize { @head.shift } || @queue.dequeue(timeout: 0)
+      end
+
+
+      # @return [Boolean]
+      #
+      def empty?
+        @mu.synchronize { @head.empty? } && @queue.empty?
+      end
+    end
+  end
+end

data/lib/omq/routing.rb

@@ -4,6 +4,7 @@ require "async"
 require "async/queue"
 require "async/limited_queue"
 require_relative "drop_queue"
+require_relative "routing/staging_queue"
 require_relative "routing/fair_queue"
 require_relative "routing/fair_recv"
 require_relative "routing/conn_send_pump"

data/lib/omq/single_frame.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OMQ
+  # Mixin that rejects multipart messages.
+  #
+  # All draft socket types (CLIENT, SERVER, RADIO, DISH, SCATTER,
+  # GATHER, PEER, CHANNEL) require single-frame messages for
+  # thread-safe atomic operations.
+  #
+  module SingleFrame
+    # Sends a message, rejecting multipart messages.
+    #
+    # @param message [String, Array<String>] message to send (must be single-frame)
+    # @raise [ArgumentError] if a multipart message is provided
+    # @return [void]
+    def send(message)
+      if message.is_a?(Array) && message.size > 1
+        raise ArgumentError, "#{self.class} does not support multipart messages"
+      end
+      super
+    end
+  end
+end

data/lib/omq/socket.rb

@@ -36,6 +36,8 @@ module OMQ
       :heartbeat_ttl,         :heartbeat_ttl=,
       :heartbeat_timeout,     :heartbeat_timeout=,
       :max_message_size,      :max_message_size=,
+      :sndbuf,                :sndbuf=,
+      :rcvbuf,                :rcvbuf=,
       :on_mute,               :on_mute=,
       :mechanism,             :mechanism=
 
@@ -170,10 +172,11 @@ module OMQ
     #   # later:
     #   task.stop
     #
-    def monitor(&block)
+    def monitor(verbose: false, &block)
       ensure_parent_task
       queue = Async::Queue.new
       @engine.monitor_queue = queue
+      @engine.verbose_monitor = verbose
       Reactor.run do
         @engine.parent_task.async(transient: true, annotation: "monitor") do
           while (event = queue.dequeue)

data/lib/omq/transport/ipc.rb

@@ -27,7 +27,7 @@ module OMQ
 
           server = UNIXServer.new(sock_path)
 
-          Listener.new(endpoint, server, path)
+          Listener.new(endpoint, server, path, engine)
         end
 
 
@@ -41,9 +41,15 @@ module OMQ
           path = parse_path(endpoint)
           sock_path = to_socket_path(path)
           sock = UNIXSocket.new(sock_path)
+          apply_buffer_sizes(sock, engine.options)
           engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
         end
 
+        def apply_buffer_sizes(sock, options)
+          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf) if options.sndbuf
+          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf) if options.rcvbuf
+        end
+
         private
 
         # Extracts path from "ipc://path".
@@ -87,11 +93,13 @@ module OMQ
         # @param endpoint [String] the IPC endpoint URI
         # @param server [UNIXServer]
         # @param path [String] filesystem or abstract namespace path
+        # @param engine [Engine]
         #
-        def initialize(endpoint, server, path)
+        def initialize(endpoint, server, path, engine)
           @endpoint = endpoint
           @server   = server
           @path     = path
+          @engine   = engine
           @task     = nil
         end
 
@@ -106,11 +114,14 @@ module OMQ
           @task = parent_task.async(transient: true, annotation: "ipc accept #{@endpoint}") do
             loop do
               client = @server.accept
+              IPC.apply_buffer_sizes(client, @engine.options)
               Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
             end
           rescue Async::Stop
           rescue IOError
             # server closed
+          rescue => e
+            $stderr.write("omq: ipc accept: #{e.class}: #{e.message}\n#{e.backtrace&.first}\n") if OMQ::DEBUG
           ensure
             @server.close rescue nil
           end

data/lib/omq/transport/tcp.rb

@@ -34,7 +34,7 @@ module OMQ
 
           host_part = host.include?(":") ? "[#{host}]" : host
           resolved  = "tcp://#{host_part}:#{actual_port}"
-          Listener.new(resolved, servers, actual_port)
+          Listener.new(resolved, servers, actual_port, engine)
         end
 
 
@@ -58,6 +58,7 @@ module OMQ
         def connect(endpoint, engine)
           host, port = self.parse_endpoint(endpoint)
           sock = TCPSocket.new(host, port)
+          apply_buffer_sizes(sock, engine.options)
           engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
         end
 
@@ -71,6 +72,12 @@ module OMQ
           uri = URI.parse(endpoint)
           [uri.hostname, uri.port]
         end
+
+
+        def apply_buffer_sizes(sock, options)
+          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf) if options.sndbuf
+          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf) if options.rcvbuf
+        end
       end
 
 
@@ -93,11 +100,13 @@ module OMQ
         # @param endpoint [String] resolved endpoint URI
         # @param servers [Array<TCPServer>]
         # @param port [Integer] bound port number
+        # @param engine [Engine]
         #
-        def initialize(endpoint, servers, port)
+        def initialize(endpoint, servers, port, engine)
           @endpoint = endpoint
           @servers  = servers
           @port     = port
+          @engine   = engine
           @tasks    = []
         end
 
@@ -113,11 +122,14 @@ module OMQ
             parent_task.async(transient: true, annotation: "tcp accept #{@endpoint}") do
               loop do
                 client = server.accept
+                TCP.apply_buffer_sizes(client, @engine.options)
                 Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
               end
             rescue Async::Stop
             rescue IOError
               # server closed
+            rescue => e
+              $stderr.write("omq: tcp accept: #{e.class}: #{e.message}\n#{e.backtrace&.first}\n") if OMQ::DEBUG
             ensure
               server.close rescue nil
             end

data/lib/omq/version.rb

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

data/lib/omq.rb

@@ -13,6 +13,11 @@ require_relative "omq/version"
 require_relative "omq/monitor_event"
 
 module OMQ
+  # When OMQ_DEBUG is set, silent rescue clauses print the exception
+  # to stderr so transport/engine bugs surface immediately.
+  DEBUG = !!ENV["OMQ_DEBUG"]
+
+
   # Raised when an internal pump task crashes unexpectedly.
   # The socket is no longer usable; the original error is available via #cause.
   #
@@ -71,6 +76,7 @@ require_relative "omq/engine"
 require_relative "omq/queue_interface"
 require_relative "omq/readable"
 require_relative "omq/writable"
+require_relative "omq/single_frame"
 
 # Socket types
 require_relative "omq/socket"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -96,9 +96,11 @@ files:
 - lib/omq/routing/req.rb
 - lib/omq/routing/round_robin.rb
 - lib/omq/routing/router.rb
+- lib/omq/routing/staging_queue.rb
 - lib/omq/routing/sub.rb
 - lib/omq/routing/xpub.rb
 - lib/omq/routing/xsub.rb
+- lib/omq/single_frame.rb
 - lib/omq/socket.rb
 - lib/omq/transport/inproc.rb
 - lib/omq/transport/inproc/direct_pipe.rb