omq 0.19.2 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19b283aa20e543617cd7be9c899d2954c219631fd57417536be4fb26798e6e85
-  data.tar.gz: a39d1c870e6171726a00a5f1809556e3ce7c3a8c0e4b0e84722eae15f83f93b6
+  metadata.gz: 6800afbb9c1e8dd9f7a973f7105ff94a13bf99bc4f6a5c302fc3ff7c2ee3220a
+  data.tar.gz: a166c7b6d54596565574b24183d64c649b8a58c8d826bf3074eb800cb9f0f52f
 SHA512:
-  metadata.gz: 7a020d02b2a1da25dd37f6ff92836348985fb7bcd7b8c17392bacb4c23d0ee443b2dd294f8e30d5df5724e11049462d428efb6d2b5a3313b479ab7a3e7e71388
-  data.tar.gz: 3b9724342594f22aabe00d1b13d7aa71bfe652ca21954c6b4789556e95743fd03d1c62214a164be8cad717405766a5d0acdbb4c3fd73a0f95aa14738cfb17d81
+  metadata.gz: 50c173ee88a276291a82864adadeb11500265d3df24164de183407af0b1586498105b4a837a75027f2762b5a91a9f70ad6dbf0a718f9dc179e920ba3a238e266
+  data.tar.gz: da22b101249f108c9dc59763f1589fb1cd350b73bdbd62a3f59424079db68cb892bc1a93052cab603ae0f62eefb35fee1ff3a10743f500ed68dab622d3a3a027

data/CHANGELOG.md

@@ -1,5 +1,73 @@
 # Changelog
 
+## 0.20.0 — 2026-04-14
+
+### Changed
+
+- **Default `linger` is now `Float::INFINITY`** (matches libzmq). Sockets
+  wait forever on close for queued messages to drain unless `linger` is
+  set explicitly. Pass `linger: 0` to keep the old "drop on close"
+  behavior. `Options#linger` now always returns a `Numeric` (never `nil`).
+- **Socket constructors accept a block.** `OMQ::PUSH.new { |p| ... }`
+  yields the socket, then closes it (even on exception) — `File.open`
+  style. Applies to every socket type.
+- **Per-socket-type constructors take the full kwarg set** they support:
+  `send_hwm`, `recv_hwm`, `send_timeout`, `recv_timeout`, `linger`,
+  `backend`, plus pattern-specific ones (`subscribe:`, `on_mute:`,
+  `conflate:`). Previously some only accepted `linger`.
+- **Hot-path recv pump: size-1 fast path for byte counting.** The
+  `FAIRNESS_BYTES` accumulator in `RecvPump#start_direct` (and its
+  transform variant) now short-circuits single-frame messages instead
+  of iterating, keeping both entry methods monomorphic for YJIT.
+- **Hot-path round-robin `batch_bytes`** short-circuits single-frame
+  batches the same way, replacing `parts.sum { ... }` with a direct
+  `bytesize` call.
+- **Fair-queue single-connection fast path.** `try_dequeue` now skips
+  `Enumerator#next` when a fair-queue recv socket has exactly one peer
+  (the common case) and dequeues directly from the sole queue.
+- **`drain_send_queues` is cancellation-safe.** `Async::Stop` raised at
+  the drain sleep point (e.g. from a parent `task.stop`) is now rescued
+  so `Socket#close` can finish the rest of its teardown instead of
+  propagating the cancellation out of the ensure path.
+- **Hot-path `Array#[0]` → `Array#first`** in writable batching and
+  pair routing — `#first` has a dedicated YJIT specialization that is
+  measurably faster on single-frame messages.
+- **Benchmark size sweep reworked.** `SIZES` is now a ×4 geometric
+  progression `128, 512, 2048, 8192, 32_768` bytes, replacing
+  `64 / 1024 / 8192 / 65_536`. Fills the 64 B → 1 KiB gap, drops 64 KiB
+  (tcp/ipc already saturated at 32 KiB, inproc regressed). `report.rb
+  --update-readme` and `bench/README.md` regenerated.
+
+### Fixed
+
+- **Slow `send_timeout` test.** The `raises IO::TimeoutError when send
+  blocks longer than send_timeout` test now constructs its PUSH with
+  `linger: 0`. Previously the undeliverable fill message combined with
+  the new default `linger: Float::INFINITY` made the close-in-ensure
+  path wait out the full linger budget, silently eating the enclosing
+  `task.with_timeout` and inflating suite runtime.
+- **Test suite runtime.** `TEST_ASYNC_TIMEOUT` lowered from 5 s to 1 s:
+  real hangs fail fast and the full suite finishes in ~3 s instead of
+  ~8 s.
+
+## 0.19.3 — 2026-04-13
+
+### Changed
+
+- Engine no longer reaches into `routing.recv_queue` directly.
+  Routing strategies now expose `#dequeue_recv` and `#unblock_recv`
+  as the engine-facing recv contract. `FairRecv` provides the
+  shared implementation for fair-queued sockets; sub/xsub/xpub
+  delegate inline; write-only push/pub raise on dequeue and no-op
+  on unblock. Sharpens the routing interface and keeps Engine out
+  of queue internals.
+- `Writable#freeze_message` collapsed: single `all?` predicate
+  check drives three outcomes (already-frozen-array fast path,
+  freeze-in-place, convert-via-map/map!) instead of mirrored
+  fast/slow branches that each repeated the predicate.
+- Hot-path optimized. Avoid the overhead of `parts.sum(&:bytesize)`
+  and use `parts.sum { |p| p.bytesize }` instead.
+
 ## 0.19.2 — 2026-04-13
 
 ### Added

data/README.md

@@ -1,41 +1,32 @@
-# OMQ — Where did the C dependency go!?
+# ØMQ — ZeroMQ for Ruby, no C required
 
 [![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/omq?color=e9573f)](https://rubygems.org/gems/omq)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
-`gem install omq` — that's it. No libzmq, no compiler, no system packages. Just Ruby.
-
-OMQ builds ZeroMQ socket patterns on top of [protocol-zmtp](https://github.com/paddor/protocol-zmtp) (a pure Ruby [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) codec) using [Async](https://github.com/socketry/async) fibers. It speaks native ZeroMQ on the wire and interoperates with libzmq, pyzmq, CZMQ, and everything else in the ZMQ ecosystem.
-
-> **980k msg/s** inproc | **38k msg/s** ipc | **31k msg/s** tcp
+> **932k msg/s** inproc | **328k msg/s** ipc | **329k msg/s** tcp
 >
-> **10 µs** inproc latency | **71 µs** ipc | **82 µs** tcp
+> **11.5 µs** inproc latency | **54 µs** ipc | **69 µs** tcp
 >
 > Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
 
----
-
-## What is ZeroMQ?
-
-Brokerless message-oriented middleware. No central server, no extra hop — processes talk directly to each other, cutting latency in half compared to broker-based systems. You get the patterns you'd normally build on top of RabbitMQ or Redis — pub/sub, work distribution, request/reply, fan-out — but decentralized, with no single point of failure.
-
-Networking is hard. ZeroMQ abstracts away reconnection, queuing, load balancing, and framing so you can focus on what your system actually does. Start with threads talking over `inproc://`, split into processes with `ipc://`, scale across machines with `tcp://` — same code, same API, just change the URL.
+`gem install omq` and you're done. No libzmq, no compiler, no system packages — just Ruby talking to every other ZeroMQ peer out there.
 
-If you've ever wired up services with raw TCP, HTTP polling, or Redis pub/sub and wished it was simpler, this is what you've been looking for.
+ØMQ gives your Ruby processes a way to talk to each other — and to anything else speaking ZeroMQ — without a broker in the middle. Same API whether they live in the same process, on the same machine, or across the network. Reconnects, queuing, and back-pressure are handled for you; you write the interesting part.
 
-See [GETTING_STARTED.md](GETTING_STARTED.md) for a ~30 min walkthrough of all major patterns with working code.
+New to ZeroMQ? Start with [GETTING_STARTED.md](GETTING_STARTED.md) — a ~30 min walkthrough of every major pattern with working code.
 
 ## Highlights
 
 - **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install` just works everywhere
-- **Fast** — YJIT-optimized hot paths, batched sends, recv prefetching, direct-pipe inproc bypass. 980k msg/s inproc, 10 µs latency
-- **[`omq` CLI](https://github.com/paddor/omq-cli)** — `gem install omq-cli` for a command-line tool with Ruby eval, Ractor parallelism, and script handlers
+- **Fast** — YJIT-optimized hot paths, batched sends, GC-tuned allocations, buffered I/O via [io-stream](https://github.com/socketry/io-stream), direct-pipe inproc bypass
+- **[`omq` CLI](https://github.com/paddor/omq-cli)** — a powerful swiss army knife for ØMQ. `gem install omq-cli`
 - **Every socket pattern** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair, and all draft types
 - **Every transport** — tcp, ipc (Unix domain sockets), inproc (in-process queues)
-- **Async-native** — built on fibers, non-blocking from the ground up. A shared IO thread handles sockets outside of Async — no reactor needed for simple scripts
-- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ over tcp and ipc
+- **Async-native** — built on fibers, non-blocking from the ground up
+- **Works outside Async too** — a shared IO thread handles sockets for callers that aren't inside a reactor, so simple scripts just work
+- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ, zmq.rs over tcp and ipc
 - **Bind/connect order doesn't matter** — connect before bind, bind before connect, peers come and go. ZeroMQ reconnects automatically and queued messages drain when peers arrive
 
 For architecture internals, see [DESIGN.md](DESIGN.md).
@@ -164,15 +155,15 @@ All sockets are thread-safe. Default HWM is 1000 messages per socket. `max_messa
 
 #### Draft (single-frame only)
 
-These require the `omq-draft` gem.
+Each draft pattern lives in its own gem — install only the ones you use.
 
-| Pattern | Send | Receive | When HWM full |
-|---------|------|---------|---------------|
-| **CLIENT** / **SERVER** | Work-stealing / routing-ID | Fair-queue | Block |
-| **RADIO** / **DISH** | Group fan-out | Group filter | Drop |
-| **SCATTER** / **GATHER** | Work-stealing | Fair-queue | Block |
-| **PEER** | Routing-ID | Fair-queue | Block |
-| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
+| Pattern | Send | Receive | When HWM full | Gem |
+|---------|------|---------|---------------|-----|
+| **CLIENT** / **SERVER** | Work-stealing / routing-ID | Fair-queue | Block | [`omq-rfc-clientserver`](https://github.com/paddor/omq-rfc-clientserver) |
+| **RADIO** / **DISH** | Group fan-out | Group filter | Drop | [`omq-rfc-radiodish`](https://github.com/paddor/omq-rfc-radiodish) |
+| **SCATTER** / **GATHER** | Work-stealing | Fair-queue | Block | [`omq-rfc-scattergather`](https://github.com/paddor/omq-rfc-scattergather) |
+| **PEER** | Routing-ID | Fair-queue | Block | [`omq-rfc-p2p`](https://github.com/paddor/omq-rfc-p2p) |
+| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block | [`omq-rfc-channel`](https://github.com/paddor/omq-rfc-channel) |
 
 ## CLI
 
@@ -192,6 +183,12 @@ See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentati
 - **[omq-ffi](https://github.com/paddor/omq-ffi)** — libzmq FFI backend. Same OMQ socket API, but backed by libzmq instead of the pure Ruby ZMTP stack. Useful for interop testing and when you need libzmq-specific features. Requires libzmq installed.
 - **[omq-ractor](https://github.com/paddor/omq-ractor)** — bridge OMQ sockets into Ruby Ractors for true parallel processing across cores. I/O stays on the main Ractor, worker Ractors do pure computation.
 
+### Protocol extensions (RFCs)
+
+Optional plug-ins that extend the ZMTP wire protocol. Each is a separate gem; load the ones you need.
+
+- **[omq-rfc-zstd](https://github.com/paddor/omq-rfc-zstd)** — transparent Zstandard compression on the wire, negotiated per peer via READY properties.
+
 ## Development
 
 ```sh
@@ -210,16 +207,16 @@ the stack.
 # clone OMQ and its sibling repos into the same parent directory
 git clone https://github.com/paddor/omq.git
 git clone https://github.com/paddor/protocol-zmtp.git
-git clone https://github.com/paddor/nuckle.git
-git clone https://github.com/paddor/omq-rfc-blake3zmq.git
-git clone https://github.com/paddor/omq-rfc-channel.git
+git clone https://github.com/paddor/omq-rfc-zstd.git
 git clone https://github.com/paddor/omq-rfc-clientserver.git
-git clone https://github.com/paddor/omq-rfc-p2p.git
-git clone https://github.com/paddor/omq-rfc-qos.git
 git clone https://github.com/paddor/omq-rfc-radiodish.git
 git clone https://github.com/paddor/omq-rfc-scattergather.git
+git clone https://github.com/paddor/omq-rfc-channel.git
+git clone https://github.com/paddor/omq-rfc-p2p.git
+git clone https://github.com/paddor/omq-rfc-qos.git
 git clone https://github.com/paddor/omq-ffi.git
 git clone https://github.com/paddor/omq-ractor.git
+git clone https://github.com/paddor/nuckle.git
 
 cd omq
 OMQ_DEV=1 bundle install

data/lib/omq/engine/recv_pump.rb

@@ -91,18 +91,34 @@ module OMQ
           loop do
             count = 0
             bytes = 0
+
             while count < FAIRNESS_MESSAGES && bytes < FAIRNESS_BYTES
               msg = conn.receive_message
               msg = transform.call(msg).freeze
+
               # Emit the verbose trace BEFORE enqueueing so the monitor
               # fiber is woken before the application fiber -- the
               # async scheduler is FIFO on the ready list, so this
               # preserves log-before-stdout ordering for -vvv traces.
               engine.emit_verbose_msg_received(conn, msg)
               recv_queue.enqueue(msg)
+
               count += 1
-              bytes += msg.sum(&:bytesize) if count_bytes
+
+              # hot path
+              if count_bytes
+                if msg.size == 1
+                  bytes += msg.first.bytesize
+                else
+                  i, n = 0, msg.size
+                  while i < n
+                    bytes += msg[i].bytesize
+                    i += 1
+                  end
+                end
+              end
             end
+
             task.yield
           end
         rescue Async::Stop, Async::Cancel
@@ -128,13 +144,28 @@ module OMQ
           loop do
             count = 0
             bytes = 0
+
             while count < FAIRNESS_MESSAGES && bytes < FAIRNESS_BYTES
               msg = conn.receive_message
               engine.emit_verbose_msg_received(conn, msg)
               recv_queue.enqueue(msg)
+
               count += 1
-              bytes += msg.sum(&:bytesize) if count_bytes
+
+              # hot path
+              if count_bytes
+                if msg.size == 1
+                  bytes += msg.first.bytesize
+                else
+                  i, n = 0, msg.size
+                  while i < n
+                    bytes += msg[i].bytesize
+                    i += 1
+                  end
+                end
+              end
             end
+
             task.yield
           end
         rescue Async::Stop, Async::Cancel

data/lib/omq/engine.rb

@@ -80,6 +80,7 @@ module OMQ
     #
     attr_reader :connections, :tasks, :lifecycle
 
+
     # @!attribute [w] monitor_queue
     #   @param value [Async::Queue, nil] queue for monitor events
     #
@@ -116,7 +117,9 @@ module OMQ
     def spawn_inproc_retry(endpoint)
       ri  = @options.reconnect_interval
       ivl = ri.is_a?(Range) ? ri.begin : ri
-      @tasks << @lifecycle.barrier.async(transient: true, annotation: "inproc reconnect #{endpoint}") do
+      ann = "inproc reconnect #{endpoint}"
+
+      @tasks << @lifecycle.barrier.async(transient: true, annotation: ann) do
         yield ivl
       rescue Async::Stop, Async::Cancel
       end
@@ -134,7 +137,9 @@ module OMQ
       capture_parent_task(parent: parent)
       transport = transport_for(endpoint)
       listener  = transport.bind(endpoint, self)
+
       start_accept_loops(listener)
+
       @listeners << listener
       @last_endpoint = listener.endpoint
       @last_tcp_port = listener.respond_to?(:port) ? listener.port : nil
@@ -155,6 +160,7 @@ module OMQ
       capture_parent_task(parent: parent)
       validate_endpoint!(endpoint)
       @dialed.add(endpoint)
+
       if endpoint.start_with?("inproc://")
         # Inproc connect is synchronous and instant
         transport = transport_for(endpoint)
@@ -188,6 +194,7 @@ module OMQ
     def unbind(endpoint)
       listener = @listeners.find { |l| l.endpoint == endpoint }
       return unless listener
+
       listener.stop
       @listeners.delete(listener)
       close_connections_at(endpoint)
@@ -235,8 +242,10 @@ module OMQ
     #
     def dequeue_recv
       raise @fatal_error if @fatal_error
-      msg = routing.recv_queue.dequeue
+
+      msg = routing.dequeue_recv
       raise @fatal_error if msg.nil? && @fatal_error
+
       msg
     end
 
@@ -245,7 +254,7 @@ module OMQ
     # pending {#dequeue_recv} with a nil return value.
     #
     def dequeue_recv_sentinel
-      routing.recv_queue.push(nil)
+      routing.unblock_recv
     end
 
 
@@ -274,6 +283,7 @@ module OMQ
       # pumps when the connection is lost.
       parent = @connections[conn]&.barrier || @lifecycle.barrier
       task   = RecvPump.start(parent, conn, recv_queue, self, transform)
+
       @tasks << task if task
       task
     end
@@ -316,11 +326,20 @@ module OMQ
     #
     def close
       return unless @lifecycle.open?
+
       @lifecycle.start_closing!
       stop_listeners unless @connections.empty?
-      drain_send_queues(@options.linger) if @options.linger.nil? || @options.linger > 0
+
+      if @options.linger.nil? || @options.linger > 0
+        drain_send_queues(@options.linger)
+      end
+
       @lifecycle.finish_closing!
-      Reactor.untrack_linger(@options.linger) if @lifecycle.on_io_thread
+
+      if @lifecycle.on_io_thread
+        Reactor.untrack_linger(@options.linger)
+      end
+
       stop_listeners
       tear_down_barrier
       routing.stop rescue nil
@@ -337,9 +356,14 @@ module OMQ
     #
     def stop
       return unless @lifecycle.alive?
+
       @lifecycle.start_closing! if @lifecycle.open?
       @lifecycle.finish_closing!
-      Reactor.untrack_linger(@options.linger) if @lifecycle.on_io_thread
+
+      if @lifecycle.on_io_thread
+        Reactor.untrack_linger(@options.linger)
+      end
+
       stop_listeners
       tear_down_barrier
       routing.stop rescue nil
@@ -407,8 +431,9 @@ module OMQ
     #
     def signal_fatal_error(error)
       return unless @lifecycle.open?
+
       @fatal_error = build_fatal_error(error)
-      routing.recv_queue.push(nil) rescue nil
+      routing.unblock_recv rescue nil
       @lifecycle.peer_connected.resolve(nil) rescue nil
     end
 
@@ -442,7 +467,10 @@ module OMQ
     # @param parent [#async, nil] optional Async parent
     #
     def capture_parent_task(parent: nil)
-      return unless @lifecycle.capture_parent_task(parent: parent, linger: @options.linger)
+      task = @lifecycle.capture_parent_task(parent: parent, linger: @options.linger)
+
+      return unless task
+
       Maintenance.start(@lifecycle.barrier, @options.mechanism, @tasks)
     end
 
@@ -491,8 +519,13 @@ module OMQ
     # +last_wire_size_in+.
     def emit_verbose_msg_received(conn, parts)
       return unless @verbose_monitor
+
       detail = { parts: parts }
-      detail[:wire_size] = conn.last_wire_size_in if conn.respond_to?(:last_wire_size_in)
+
+      if conn.respond_to?(:last_wire_size_in)
+        detail[:wire_size] = conn.last_wire_size_in
+      end
+
       emit_monitor_event(:message_received, detail: detail)
     end
 
@@ -504,9 +537,14 @@ module OMQ
     # @raise [ArgumentError] if the scheme is not registered
     #
     def transport_for(endpoint)
-      scheme = endpoint[/\A([^:]+):\/\//, 1]
-      self.class.transports[scheme] or
+      scheme    = endpoint[/\A([^:]+):\/\//, 1]
+      transport = self.class.transports[scheme]
+
+      unless transport
         raise ArgumentError, "unsupported transport: #{endpoint}"
+      end
+
+      transport
     end
 
 
@@ -528,6 +566,7 @@ module OMQ
       ensure
         lifecycle&.close!
       end
+
       @tasks << task if task
     end
 
@@ -539,11 +578,19 @@ module OMQ
     # every routing strategy, so it is flagged rather than fixed here.
     def drain_send_queues(timeout)
       return unless @routing.respond_to?(:send_queues_drained?)
-      deadline = timeout ? Async::Clock.now + timeout : nil
+
+      if timeout
+        deadline = Async::Clock.now + timeout
+      end
+
       until @routing.send_queues_drained?
         break if deadline && (deadline - Async::Clock.now) <= 0
         sleep 0.001
       end
+    rescue Async::Stop
+      # Parent task is being cancelled — stop draining and let close
+      # proceed with the rest of teardown instead of propagating the
+      # cancellation out of the ensure path.
     end
 
 
@@ -554,12 +601,16 @@ module OMQ
 
     def validate_endpoint!(endpoint)
       transport = transport_for(endpoint)
-      transport.validate_endpoint!(endpoint) if transport.respond_to?(:validate_endpoint!)
+
+      if transport.respond_to?(:validate_endpoint!)
+        transport.validate_endpoint!(endpoint)
+      end
     end
 
 
     def start_accept_loops(listener)
       return unless listener.respond_to?(:start_accept_loops)
+
       listener.start_accept_loops(@lifecycle.barrier) do |io|
         handle_accepted(io, endpoint: listener.endpoint)
       end

data/lib/omq/options.rb

@@ -10,9 +10,11 @@ module OMQ
     DEFAULT_HWM = 1000
 
 
-    # @param linger [Integer] linger period in seconds (default 0)
+    # @param linger [Numeric] linger period in seconds on close
+    #   (default Float::INFINITY = wait forever, matching libzmq).
+    #   Pass 0 for immediate drop-on-close.
     #
-    def initialize(linger: 0)
+    def initialize(linger: Float::INFINITY)
       @send_hwm              = DEFAULT_HWM
       @recv_hwm              = DEFAULT_HWM
       @linger                = linger
@@ -39,7 +41,8 @@ module OMQ
     # @!attribute recv_hwm
     #   @return [Integer] receive high water mark (default 1000, 0 = unbounded)
     # @!attribute linger
-    #   @return [Integer, nil] linger period in seconds (nil = wait forever, 0 = immediate)
+    #   @return [Numeric] linger period in seconds on close
+    #     (Float::INFINITY = wait forever, 0 = immediate drop)
     # @!attribute identity
     #   @return [String] socket identity for ROUTER addressing (default "")
     # @!attribute router_mandatory

data/lib/omq/pair.rb

@@ -8,12 +8,25 @@ module OMQ
     include Writable
 
     # @param endpoints [String, nil] endpoint to bind/connect
-    # @param linger [Integer] linger period in seconds
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param send_hwm [Integer, nil] send high water mark (nil uses default)
+    # @param recv_hwm [Integer, nil] receive high water mark (nil uses default)
+    # @param send_timeout [Numeric, nil] send timeout in seconds
+    # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      init_engine(:PAIR, linger: linger, backend: backend)
+    def initialize(endpoints = nil, linger: Float::INFINITY,
+                   send_hwm: nil, recv_hwm: nil,
+                   send_timeout: nil, recv_timeout: nil,
+                   backend: nil, &block)
+      init_engine(:PAIR, send_hwm: send_hwm, recv_hwm: recv_hwm,
+                  send_timeout: send_timeout, recv_timeout: recv_timeout,
+                  backend: backend)
+      @options.linger = linger
       attach_endpoints(endpoints, default: :connect)
+      finalize_init(&block)
     end
+
   end
+
 end

data/lib/omq/pub_sub.rb

@@ -7,15 +7,23 @@ module OMQ
     include Writable
 
     # @param endpoints [String, nil] endpoint to bind/connect
-    # @param linger [Integer] linger period in seconds
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param send_hwm [Integer, nil] send high water mark
+    # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param on_mute [Symbol] mute strategy for slow subscribers
     # @param conflate [Boolean] keep only latest message per topic
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, on_mute: :drop_newest, conflate: false, backend: nil)
-      init_engine(:PUB, linger: linger, on_mute: on_mute, conflate: conflate, backend: backend)
+    def initialize(endpoints = nil, linger: Float::INFINITY,
+                   send_hwm: nil, send_timeout: nil,
+                   on_mute: :drop_newest, conflate: false, backend: nil, &block)
+      init_engine(:PUB, send_hwm: send_hwm, send_timeout: send_timeout,
+                  on_mute: on_mute, conflate: conflate, backend: backend)
+      @options.linger = linger
       attach_endpoints(endpoints, default: :bind)
+      finalize_init(&block)
     end
+
   end
 
 
@@ -29,16 +37,21 @@ module OMQ
     EVERYTHING = ''
 
 
-    # @param endpoints [String, nil]
-    # @param linger [Integer]
+    # @param endpoints [String, nil] endpoint to bind/connect
+    # @param recv_hwm [Integer, nil] receive high water mark
+    # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — call {#subscribe} explicitly.
     # @param on_mute [Symbol] :block (default), :drop_newest, or :drop_oldest
+    # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, subscribe: nil, on_mute: :block, backend: nil)
-      init_engine(:SUB, linger: linger, on_mute: on_mute, backend: backend)
+    def initialize(endpoints = nil, recv_hwm: nil, recv_timeout: nil,
+                   subscribe: nil, on_mute: :block, backend: nil, &block)
+      init_engine(:SUB, recv_hwm: recv_hwm, recv_timeout: recv_timeout,
+                  on_mute: on_mute, backend: backend)
       attach_endpoints(endpoints, default: :connect)
       self.subscribe(subscribe) unless subscribe.nil?
+      finalize_init(&block)
     end
 
 
@@ -60,6 +73,7 @@ module OMQ
     def unsubscribe(prefix)
       @engine.routing.unsubscribe(prefix)
     end
+
   end
 
 
@@ -70,14 +84,26 @@ module OMQ
     include Writable
 
     # @param endpoints [String, nil] endpoint to bind/connect
-    # @param linger [Integer] linger period in seconds
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param send_hwm [Integer, nil] send high water mark
+    # @param recv_hwm [Integer, nil] receive high water mark
+    # @param send_timeout [Numeric, nil] send timeout in seconds
+    # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param on_mute [Symbol] mute strategy for slow subscribers
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, on_mute: :drop_newest, backend: nil)
-      init_engine(:XPUB, linger: linger, on_mute: on_mute, backend: backend)
+    def initialize(endpoints = nil, linger: Float::INFINITY,
+                   send_hwm: nil, recv_hwm: nil,
+                   send_timeout: nil, recv_timeout: nil,
+                   on_mute: :drop_newest, backend: nil, &block)
+      init_engine(:XPUB, send_hwm: send_hwm, recv_hwm: recv_hwm,
+                  send_timeout: send_timeout, recv_timeout: recv_timeout,
+                  on_mute: on_mute, backend: backend)
+      @options.linger = linger
       attach_endpoints(endpoints, default: :bind)
+      finalize_init(&block)
     end
+
   end
 
 
@@ -87,17 +113,30 @@ module OMQ
     include Readable
     include Writable
 
-    # @param endpoints [String, nil]
-    # @param linger [Integer]
+    # @param endpoints [String, nil] endpoint to bind/connect
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param send_hwm [Integer, nil] send high water mark
+    # @param recv_hwm [Integer, nil] receive high water mark
+    # @param send_timeout [Numeric, nil] send timeout in seconds
+    # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — send a subscribe frame explicitly.
     # @param on_mute [Symbol] mute strategy (:block, :drop_newest, :drop_oldest)
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, subscribe: nil, on_mute: :block, backend: nil)
-      init_engine(:XSUB, linger: linger, on_mute: on_mute, backend: backend)
+    def initialize(endpoints = nil, linger: Float::INFINITY,
+                   send_hwm: nil, recv_hwm: nil,
+                   send_timeout: nil, recv_timeout: nil,
+                   subscribe: nil, on_mute: :block, backend: nil, &block)
+      init_engine(:XSUB, send_hwm: send_hwm, recv_hwm: recv_hwm,
+                  send_timeout: send_timeout, recv_timeout: recv_timeout,
+                  on_mute: on_mute, backend: backend)
+      @options.linger = linger
       attach_endpoints(endpoints, default: :connect)
       send("\x01#{subscribe}".b) unless subscribe.nil?
+      finalize_init(&block)
     end
+
   end
+
 end