omq 0.19.3 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77ae2b0a529e29f7c7c48478db4b9b0d81955b28dca48cd17c4f5dfb1dbfd118
-  data.tar.gz: 2ec4f56b9893527d6458e366835878902d3ec254893de2fa0e7579d52be73438
+  metadata.gz: f24ac91fe456168b4d369f63506cf1d3d2b48488637ce767363aa17bb542d2b3
+  data.tar.gz: ca1b98ab4083ad90f7f483bc9df937656ae9862c9fd07800fc46315543e5fe75
 SHA512:
-  metadata.gz: af73f9a2031c776167a616fe2e63775cd036c6f02f24cdb65059a4ffb81572e2747a9a4f662b96bd7574ecac3d48114f7ea3569bfbc1f6f3bc0f571a523df1ca
-  data.tar.gz: e919e6bce582848096c692a76e63081b038fb77a9796e914f2265c1825d36017278d46b014b639bbc100935be3ae82af1ac1bfde29951e49e2643ac942d6c251
+  metadata.gz: 16f20fa600ebd66228589da4e03efc809a616d6a74fbe3460a8ced6811349fb86903e43a440708e1e78f102af711d6f9ea3ebf9cbc0e7fb4aef9591db5061e39
+  data.tar.gz: 89ff3da1bb5caa2223d1e323a389cacc4f270fed719902dbd0721c56da8ff5c0a1cbf1e6eebc59c8386f470c433c69dfb20462d46f84c9a2fa848b3e1364dfd0

data/CHANGELOG.md

@@ -1,5 +1,87 @@
 # Changelog
 
+## 0.21.0 — 2026-04-15
+
+### Changed
+
+- **Recv path: shared queue, no more `FairQueue`.** Every fair-queue
+  routing strategy (Pull, Pair, Rep, Dealer, Router, Req, Sub, XSub)
+  now owns a single `Async::LimitedQueue` sized to `recv_hwm`. Each
+  connection's recv pump writes directly into it. `FairQueue`,
+  `SignalingQueue`, and the `FairRecv` mixin are deleted. Cross-peer
+  fairness comes entirely from the pump yield limit; per-connection
+  ordering is preserved; cross-connection ordering was never a
+  guarantee. Symmetric with the send side, which already uses one
+  work-stealing queue per socket. Sister gems (channel, clientserver,
+  p2p, radiodish, scattergather, qos) updated to match.
+- **Recv pump fairness bumped to 256 msgs / 512 KiB** (was 64 / 1 MiB),
+  symmetric with `RoundRobin::BATCH_MSG_CAP` / `BATCH_BYTE_CAP` on the
+  send side.
+
+### Added
+
+- **`Socket#attach_endpoints` accepts arrays.** Constructors passed an
+  array of endpoint strings now bind/connect each one in order, so
+  `OMQ::SUB.new(["inproc://a", "inproc://b"])` works.
+- **PUB/SUB regression test** for a SUB with sequential post-hoc
+  `#connect` calls to multiple bound PUBs, mirroring the SCATTER/GATHER
+  post-hoc-connect coverage.
+- **DESIGN.md: "Libzmq quirks OMQ avoids"** — per-pipe HWM (actual
+  buffering is `send_hwm × N_peers`, forces strict RR, slow-worker
+  stall footgun) and the edge-triggered `ZMQ_FD` that fires spuriously
+  and misses edges, requiring the `ZMQ_EVENTS` / `ZMQ_DONTWAIT` dance.
+  README "Socket Types" condensed to a pointer at DESIGN.md.
+
+## 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

data/README.md

@@ -1,42 +1,49 @@
-# 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
+> **1.23M msg/s** inproc | **361k msg/s** ipc | **358k msg/s** tcp
 >
-> **10 µs** inproc latency | **71 µs** ipc | **82 µs** tcp
+> **9.1 µs** inproc latency | **49 µs** ipc | **64 µ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
-- **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
-- **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
+- **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install`
+  just works everywhere
+- **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
+- **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).
 
@@ -108,7 +115,8 @@ end
 
 ### Without Async (IO thread)
 
-OMQ spawns a shared `omq-io` thread when used outside an Async reactor — no boilerplate needed:
+OMQ spawns a shared `omq-io` thread when used outside an Async reactor — no
+boilerplate needed:
 
 ```ruby
 require 'omq'
@@ -123,7 +131,8 @@ push.close
 pull.close
 ```
 
-The IO thread runs all pumps, reconnection, and heartbeating in the background. When you're inside an `Async` block, OMQ uses the existing reactor instead.
+The IO thread runs all pumps, reconnection, and heartbeating in the background.
+When you're inside an `Async` block, OMQ uses the existing reactor instead.
 
 ### Queue Interface
 
@@ -147,7 +156,11 @@ end
 
 ## Socket Types
 
-All sockets are thread-safe. Default HWM is 1000 messages per socket. `max_message_size` defaults to **`nil` (unlimited)** — set `socket.max_message_size = N` to cap inbound frames at `N` bytes; oversized frames cause the connection to be dropped before the body is read from the wire. Classes live under `OMQ::` (alias: `ØMQ`).
+All sockets are thread-safe. Default HWM is 1000 messages per socket.
+`max_message_size` defaults to **`nil` (unlimited)** — set
+`socket.max_message_size = N` to cap inbound frames at `N` bytes; oversized
+frames cause the connection to be dropped before the body is read from the
+wire. Classes live under `OMQ::` (alias: `ØMQ`).
 
 #### Standard (multipart messages)
 
@@ -160,23 +173,28 @@ All sockets are thread-safe. Default HWM is 1000 messages per socket. `max_messa
 | **XPUB** / **XSUB** | Fan-out (subscription events) | Fair-queue | Drop |
 | **PAIR** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
 
-> **Work-stealing vs. round-robin.** libzmq uses strict per-pipe round-robin for outbound load balancing — message N goes to peer N mod K regardless of whether that peer is busy. OMQ uses **work-stealing**: one shared send queue per socket and N pump fibers that race to drain it. Whichever pump is ready next picks up the next batch, so a slow peer can't stall the pipeline. The trade-off: distribution is not strict round-robin under bursts. If a producer enqueues a large burst before any pump fiber gets scheduled, the first pump to wake will dequeue up to one whole batch (256 messages or 512 KB, whichever hits first) in a single non-blocking drain — so a tight `n.times { sock << msg }` loop on a small `n` may dump everything on one peer. Slow or steady producers don't see this: each pump dequeues one message, writes, re-parks, and the FIFO wait queue gives every pump a fair turn. Burst distribution also evens out once the burst exceeds one pump's batch cap. See [DESIGN.md](DESIGN.md#per-socket-hwm-not-per-connection) for the full reasoning.
+> **Work-stealing, not round-robin.** Outbound load balancing uses one shared
+> send queue per socket drained by N racing pump fibers, so a slow peer can't
+> stall the pipeline. Under tight bursts on small `n`, distribution isn't
+> strict RR. See [DESIGN.md](DESIGN.md#per-socket-hwm-not-per-connection) and
+> [Libzmq quirks](DESIGN.md#libzmq-quirks-omq-avoids) for the reasoning.
 
 #### 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
 
-Install [omq-cli](https://github.com/paddor/omq-cli) for a command-line tool that sends, receives, pipes, and transforms ZeroMQ messages from the terminal:
+Install [omq-cli](https://github.com/paddor/omq-cli) for a command-line tool
+that sends, receives, pipes, and transforms ZeroMQ messages from the terminal:
 
 ```sh
 gem install omq-cli
@@ -189,8 +207,21 @@ See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentati
 
 ## Companion Gems
 
-- **[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.
+- **[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
 
@@ -210,16 +241,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

@@ -15,22 +15,22 @@ module OMQ
     class RecvPump
       # Max messages read from one connection before yielding to the
       # scheduler. Prevents a busy peer from starving its siblings in
-      # fair-queue recv sockets.
-      FAIRNESS_MESSAGES = 64
+      # fair-queue recv sockets. Symmetric with RoundRobin send batching.
+      FAIRNESS_MESSAGES = 256
 
 
       # Max bytes read from one connection before yielding. Only counted
       # for ZMTP connections (inproc skips the check). Complements
       # {FAIRNESS_MESSAGES}: small-message floods are bounded by count,
-      # large-message floods by bytes.
-      FAIRNESS_BYTES    = 1 << 20 # 1 MB
+      # large-message floods by bytes. Symmetric with RoundRobin send batching.
+      FAIRNESS_BYTES    = 512 * 1024
 
 
       # Public entry point — callers use the class method.
       #
       # @param parent [Async::Task, Async::Barrier] parent to spawn under
       # @param conn [Connection, Transport::Inproc::DirectPipe]
-      # @param recv_queue [SignalingQueue]
+      # @param recv_queue [Async::LimitedQueue]
       # @param engine [Engine]
       # @param transform [Proc, nil]
       # @return [Async::Task, nil]
@@ -41,7 +41,7 @@ module OMQ
 
 
       # @param conn [Connection, Transport::Inproc::DirectPipe]
-      # @param recv_queue [Routing::SignalingQueue]
+      # @param recv_queue [Async::LimitedQueue]
       # @param engine [Engine]
       #
       def initialize(conn, recv_queue, engine)
@@ -104,7 +104,19 @@ module OMQ
               recv_queue.enqueue(msg)
 
               count += 1
-              bytes += msg.sum { |part| part.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
@@ -132,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 { |part| part.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

@@ -273,7 +273,7 @@ module OMQ
     # Starts a recv pump for a connection, or wires the inproc fast path.
     #
     # @param conn [Connection, Transport::Inproc::DirectPipe]
-    # @param recv_queue [SignalingQueue]
+    # @param recv_queue [Async::LimitedQueue]
     # @yield [msg] optional per-message transform
     # @return [Async::Task, nil]
     #
@@ -587,6 +587,10 @@ module OMQ
         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
 
 

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

data/lib/omq/push_pull.rb

@@ -7,15 +7,18 @@ 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 send_timeout [Numeric, nil] send timeout in seconds
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil, backend: nil)
-      init_engine(:PUSH, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
+    def initialize(endpoints = nil, linger: Float::INFINITY, send_hwm: nil, send_timeout: nil, backend: nil, &block)
+      init_engine(:PUSH, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
+      @options.linger = linger
       attach_endpoints(endpoints, default: :connect)
+      finalize_init(&block)
     end
+
   end
 
 
@@ -25,14 +28,16 @@ module OMQ
     include Readable
 
     # @param endpoints [String, nil] endpoint to bind/connect
-    # @param linger [Integer] linger period in seconds
     # @param recv_hwm [Integer, nil] receive high water mark (nil uses default)
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil, backend: nil)
-      init_engine(:PULL, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)
+    def initialize(endpoints = nil, recv_hwm: nil, recv_timeout: nil, backend: nil, &block)
+      init_engine(:PULL, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)
       attach_endpoints(endpoints, default: :bind)
+      finalize_init(&block)
     end
+
   end
+
 end