omq 0.19.3 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77ae2b0a529e29f7c7c48478db4b9b0d81955b28dca48cd17c4f5dfb1dbfd118
-  data.tar.gz: 2ec4f56b9893527d6458e366835878902d3ec254893de2fa0e7579d52be73438
+  metadata.gz: 6800afbb9c1e8dd9f7a973f7105ff94a13bf99bc4f6a5c302fc3ff7c2ee3220a
+  data.tar.gz: a166c7b6d54596565574b24183d64c649b8a58c8d826bf3074eb800cb9f0f52f
 SHA512:
-  metadata.gz: af73f9a2031c776167a616fe2e63775cd036c6f02f24cdb65059a4ffb81572e2747a9a4f662b96bd7574ecac3d48114f7ea3569bfbc1f6f3bc0f571a523df1ca
-  data.tar.gz: e919e6bce582848096c692a76e63081b038fb77a9796e914f2265c1825d36017278d46b014b639bbc100935be3ae82af1ac1bfde29951e49e2643ac942d6c251
+  metadata.gz: 50c173ee88a276291a82864adadeb11500265d3df24164de183407af0b1586498105b4a837a75027f2762b5a91a9f70ad6dbf0a718f9dc179e920ba3a238e266
+  data.tar.gz: da22b101249f108c9dc59763f1589fb1cd350b73bdbd62a3f59424079db68cb892bc1a93052cab603ae0f62eefb35fee1ff3a10743f500ed68dab622d3a3a027

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # 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

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

@@ -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

@@ -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

data/lib/omq/req_rep.rb

@@ -8,13 +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
+    # @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 backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      init_engine(:REQ, 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(:REQ, 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
 
 
@@ -25,12 +37,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
+    # @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 backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      init_engine(:REP, 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(:REP, 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: :bind)
+      finalize_init(&block)
     end
+
   end
+
 end

data/lib/omq/router_dealer.rb

@@ -8,13 +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
+    # @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 backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      init_engine(:DEALER, 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(:DEALER, 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
 
 
@@ -25,12 +37,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 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 backend [Symbol, nil] :ruby (default) or :ffi
     #
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      init_engine(:ROUTER, 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(:ROUTER, 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: :bind)
+      finalize_init(&block)
     end
 
 
@@ -44,5 +67,7 @@ module OMQ
       parts = message.is_a?(Array) ? message : [message]
       send([receiver, '', *parts])
     end
+
   end
+
 end

data/lib/omq/routing/fair_queue.rb

@@ -124,6 +124,12 @@ module OMQ
           end
         end
 
+        # Single-connection fast path: skip Enumerator#next entirely.
+        # The vast majority of sockets have exactly one peer.
+        if @queues.size == 1
+          return @queues.first.dequeue(timeout: 0)
+        end
+
         @queues.size.times do
           q = begin
                 @cycle.next

data/lib/omq/routing/pair.rb

@@ -96,7 +96,7 @@ module OMQ
             Routing.drain_send_queue(@send_queue, batch)
 
             if batch.size == 1
-              conn.write_message(batch[0])
+              conn.write_message(batch.first)
             else
               conn.write_messages(batch)
             end

data/lib/omq/routing/round_robin.rb

@@ -158,7 +158,7 @@ module OMQ
 
 
       def drain_send_queue_capped(batch)
-        bytes = batch_bytes(batch[0])
+        bytes = batch_bytes(batch.first)
         while batch.size < BATCH_MSG_CAP && bytes < BATCH_BYTE_CAP
           msg = @send_queue.dequeue(timeout: 0)
           break unless msg
@@ -174,13 +174,25 @@ module OMQ
       # fairness cap rather than crashing on #bytesize.
       #
       def batch_bytes(parts)
-        parts.sum { |p| p.respond_to?(:bytesize) ? p.bytesize : 0 }
+        if parts.size == 1
+          p = parts.first
+          p.respond_to?(:bytesize) ? p.bytesize : 0
+        else
+          total = 0
+          i, n  = 0, parts.size
+          while i < n
+            p      = parts[i]
+            total += p.bytesize if p.respond_to?(:bytesize)
+            i     += 1
+          end
+          total
+        end
       end
 
 
       def write_batch(conn, batch)
         if batch.size == 1
-          conn.send_message(transform_send(batch[0]))
+          conn.send_message(transform_send(batch.first))
         else
           conn.write_messages(batch)
           conn.flush

data/lib/omq/socket.rb

@@ -73,9 +73,28 @@ module OMQ
 
     # @param endpoints [String, nil] optional endpoint with prefix convention
     #   (+@+ for bind, +>+ for connect, plain uses subclass default)
-    # @param linger [Integer] linger period in seconds (default 0)
     #
-    def initialize(endpoints = nil, linger: 0)
+    # @yieldparam [self] the socket, when a block is passed; the socket
+    #   is {#close}d when the block returns (or raises).
+    #
+    # Use option accessors (e.g. +socket.linger = 0+) to configure
+    # post-construction.
+    #
+    def initialize(endpoints = nil)
+    end
+
+
+    # Yields +self+ if a block was given, then closes. Called by every
+    # subclass initializer so +OMQ::PUSH.new { |p| ... }+ behaves like
+    # +File.open+: configure, use, auto-close.
+    #
+    def finalize_init
+      return unless block_given?
+      begin
+        yield self
+      ensure
+        close
+      end
     end
 
 
@@ -294,12 +313,11 @@ module OMQ
     # subclass initializers (including out-of-tree socket types).
     #
     # @param socket_type [Symbol]
-    # @param linger [Integer]
     #
-    def init_engine(socket_type, linger:, send_hwm: nil, recv_hwm: nil,
+    def init_engine(socket_type, send_hwm: nil, recv_hwm: nil,
                     send_timeout: nil, recv_timeout: nil, conflate: false,
                     on_mute: nil, backend: nil)
-      @options = Options.new(linger: linger)
+      @options = Options.new
       @options.send_hwm     = send_hwm     if send_hwm
       @options.recv_hwm     = recv_hwm     if recv_hwm
       @options.send_timeout = send_timeout if send_timeout

data/lib/omq/version.rb

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

metadata

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