omq 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d49a1c7caa7a1548615285ae294341b31833fd02bb60a7fa7cbfc0ed5c707d79
-  data.tar.gz: db36537c5dab13faa9cbdbe611c282cbf9dd96726e88145f80c3aaa7bf3df8a5
+  metadata.gz: 0dc74658712882f8d0eb8f58b0c9a37c959d50c87116677d23be39904f7002e7
+  data.tar.gz: 1ba17796cac6b1cd594ebbee874428e0675153d461d168e0f69f07abab608ef8
 SHA512:
-  metadata.gz: 3e3a9e5a0b9ee3857a2946e7468ea2ca30c87544fa75965c79b1ea905c3a8d969aeb94b49282acd502d2ffbb6a0db5b2952f7a18a17e90363f1c5ed13cfbecd4
-  data.tar.gz: 1cb5f13312278d55684f22c420f17287a922633eebdfd143336415aafdc725dd7a38e23b5f9387cc55bf28acc0b125840c5770ef9112556b97b7c3cca8578ee6
+  metadata.gz: 3628a755a53010690ae407ac790eb83ef7592ac5cac34bddff8a62782c20cb6092c3dd300ae71a2dfff324eaf8457ba319305b6892ca259f8990ce63267c74e0
+  data.tar.gz: 76502cad1a484cf8224285fbf4259e9ba8e5daa396caa42ac3716b50ada2e72a4c31b8d256208ab7410f5e48727216fee526efbf6166e3a1a32bb7bc1701cacb

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.4.2 — 2026-03-27
+
+### Fixed
+
+- Send pump dies permanently on connection loss — `rescue` was outside
+  the loop, so a single `CONNECTION_LOST` killed the pump and all
+  subsequent messages queued but never sent
+- NULL handshake deadlocks with buffered IO — missing `io.flush` after
+  greeting and READY writes caused both peers to block on read
+- Inproc DirectPipe drops messages when send pump runs before
+  `direct_recv_queue` is wired — now buffers to `@pending_direct` and
+  drains on assignment
+- HWM and timeout options set after construction had no effect because
+  `Async::LimitedQueue` was already allocated with the default
+
+### Added
+
+- `send_hwm:`, `send_timeout:` constructor kwargs for `PUSH`
+- `recv_hwm:`, `recv_timeout:` constructor kwargs for `PULL`
+
+### Changed
+
+- Use `Async::Clock.now` instead of `Process.clock_gettime` internally
+
+## 0.4.1 — 2026-03-27
+
+### Improved
+
+- Explicit flush after `send_message`/`send_command` instead of
+  `minimum_write_size: 0` workaround — enables write buffering
+  (multi-frame messages coalesced into fewer syscalls).
+  **+68% inproc throughput** (145k → 244k msg/s),
+  **-40% inproc latency** (15 → 9 µs)
+
+### Fixed
+
+- Require `async ~> 2.38` for `Promise#wait?` (was `~> 2`)
+
 ## 0.4.0 — 2026-03-27
 
 ### Added (omqcat)
@@ -123,4 +161,4 @@ Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
 - Linger on close (drain send queue before closing)
 - `max_message_size` enforcement
 - Works inside Async reactors or standalone (shared IO thread)
-- Optional CURVE encryption via the [omq-curve](https://github.com/paddor/omq-curve) gem
+- Optional CURVE encryption via the [omq-curve](https://github.com/zeromq/omq-curve) gem

data/README.md

@@ -1,17 +1,17 @@
 # OMQ! Where did the C dependency go?!
 
-[![CI](https://github.com/paddor/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/paddor/omq/actions/workflows/ci.yml)
+[![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)
 
 Pure Ruby implementation of the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire protocol ([ZeroMQ](https://zeromq.org/)) using the [Async](https://github.com/socketry/async) gem. No native libraries required.
 
-> **145k msg/s** inproc | **40k msg/s** ipc | **32k msg/s** tcp
+> **244k msg/s** inproc | **47k msg/s** ipc | **36k msg/s** tcp
 >
-> **15 µs** inproc latency | **62 µs** ipc | **88 µs** tcp
+> **9 µs** inproc latency | **47 µs** ipc | **61 µs** tcp
 >
-> Ruby 4.0 + YJIT on a Linux VM on a 2019 MacBook Pro (Intel) — [223k msg/s with io_uring](bench/README.md#io_uring)
+> Ruby 4.0 + YJIT on a Linux VM on a 2019 MacBook Pro (Intel) — [~340k msg/s with io_uring](bench/README.md#io_uring)
 
 ---
 
@@ -121,19 +121,19 @@ req = ØMQ::REQ.new(">tcp://localhost:5555")
 
 ## Performance
 
-Benchmarked with benchmark-ips on Linux x86_64 (Ruby 4.0.1 +YJIT):
+Benchmarked with benchmark-ips on Linux x86_64 (Ruby 4.0.2 +YJIT):
 
 #### Throughput (push/pull, 64 B messages)
 
 | inproc | ipc | tcp |
 |--------|-----|-----|
-| 184k/s | 35k/s | 18k/s |
+| 244k/s | 47k/s | 36k/s |
 
 #### Latency (req/rep roundtrip)
 
 | inproc | ipc | tcp |
 |--------|-----|-----|
-| 13 µs | 70 µs | 97 µs |
+| 9 µs | 47 µs | 61 µs |
 
 See [`bench/`](bench/) for full results and scripts.
 
@@ -142,7 +142,10 @@ See [`bench/`](bench/) for full results and scripts.
 `omqcat` is a command-line tool for sending and receiving messages on any OMQ socket. Like `nngcat` from libnng, but with Ruby superpowers.
 
 ```sh
-# Echo server in one line
+# Echo server
+omqcat rep -b tcp://:5555 --echo
+
+# Upcase server in one line
 omqcat rep -b tcp://:5555 -e '$F.map(&:upcase)'
 
 # Client
@@ -170,8 +173,10 @@ omqcat pull -b tcp://:5557 -J
 omqcat push -c tcp://remote:5557 -z < data.txt
 omqcat pull -b tcp://:5557 -z
 
-# CURVE encryption (auto-detected from env vars)
-SERVER_KEY=... omqcat req -c tcp://secure:5555 -D "secret"
+# CURVE encryption
+omqcat rep -b tcp://:5555 -D "secret" --curve-server
+# prints: OMQ_SERVER_KEY='...'
+omqcat req -c tcp://localhost:5555 --curve-server-key '...'
 ```
 
 The `-e` flag runs Ruby inside the socket instance — the full socket API (`self <<`, `send`, `subscribe`, ...) is available. Use `-r` to require gems:

data/lib/omq/push_pull.rb

@@ -4,8 +4,8 @@ module OMQ
   class PUSH < Socket
     include ZMTP::Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PUSH, linger: linger)
+    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil)
+      _init_engine(:PUSH, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout)
       _attach(endpoints, default: :connect)
     end
   end
@@ -13,8 +13,8 @@ module OMQ
   class PULL < Socket
     include ZMTP::Readable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PULL, linger: linger)
+    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil)
+      _init_engine(:PULL, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout)
       _attach(endpoints, default: :bind)
     end
   end

data/lib/omq/socket.rb

@@ -164,8 +164,13 @@ module OMQ
     # @param socket_type [Symbol]
     # @param linger [Integer]
     #
-    def _init_engine(socket_type, linger:)
+    def _init_engine(socket_type, linger:, send_hwm: nil, recv_hwm: nil,
+                     send_timeout: nil, recv_timeout: nil)
       @options = ZMTP::Options.new(linger: linger)
+      @options.send_hwm     = send_hwm     if send_hwm
+      @options.recv_hwm     = recv_hwm     if recv_hwm
+      @options.send_timeout  = send_timeout if send_timeout
+      @options.recv_timeout  = recv_timeout if recv_timeout
       @engine  = ZMTP::Engine.new(socket_type, @options)
     end
   end

data/lib/omq/version.rb

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

data/lib/omq/zmtp/connection.rb

@@ -92,6 +92,7 @@ module OMQ
               @io.write(Codec::Frame.new(part, more: more).to_wire)
             end
           end
+          @io.flush
         end
       end
 
@@ -156,6 +157,7 @@ module OMQ
           else
             @io.write(command.to_frame.to_wire)
           end
+          @io.flush
         end
       end
 
@@ -216,7 +218,7 @@ module OMQ
       end
 
       def monotonic_now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Async::Clock.now
       end
 
       # Sends one frame to the wire.

data/lib/omq/zmtp/engine.rb

@@ -243,11 +243,11 @@ module OMQ
       #
       def drain_send_queues(timeout)
         return unless @routing.respond_to?(:send_queue)
-        deadline = timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil
+        deadline = timeout ? Async::Clock.now + timeout : nil
 
         until @routing.send_queue.empty?
           if deadline
-            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            remaining = deadline - Async::Clock.now
             break if remaining <= 0
           end
           sleep 0.001

data/lib/omq/zmtp/mechanism/null.rb

@@ -26,6 +26,7 @@ module OMQ
         def handshake!(io, as_server:, socket_type:, identity:)
           # Send our greeting
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
+          io.flush
 
           # Read peer greeting
           greeting_data = io.read_exactly(Codec::Greeting::SIZE)
@@ -38,6 +39,7 @@ module OMQ
           # Send our READY command
           ready_cmd = Codec::Command.ready(socket_type: socket_type, identity: identity)
           io.write(ready_cmd.to_frame.to_wire)
+          io.flush
 
           # Read peer READY command
           frame = Codec::Frame.read_from(io)

data/lib/omq/zmtp/routing/round_robin.rb

@@ -56,13 +56,18 @@ module OMQ
           @tasks << Reactor.spawn_pump do
             loop do
               parts = @send_queue.dequeue
-              conn  = next_connection
-              conn.send_message(transform_send(parts))
+              send_with_retry(parts)
             end
-          rescue *ZMTP::CONNECTION_LOST
-            # connection lost mid-write
           end
         end
+
+        def send_with_retry(parts)
+          conn = next_connection
+          conn.send_message(transform_send(parts))
+        rescue *ZMTP::CONNECTION_LOST
+          @engine.connection_lost(conn)
+          retry
+        end
       end
     end
   end

data/lib/omq/zmtp/transport/inproc.rb

@@ -202,7 +202,7 @@ module OMQ
           # @return [Async::LimitedQueue, nil] when set, {#send_message}
           #   enqueues directly here instead of using the internal queue
           #
-          attr_accessor :direct_recv_queue
+          attr_reader :direct_recv_queue
 
           # @return [Proc, nil] optional transform applied before
           #   enqueuing into {#direct_recv_queue}
@@ -224,6 +224,20 @@ module OMQ
             @peer                  = nil
             @direct_recv_queue     = nil
             @direct_recv_transform = nil
+            @pending_direct        = nil
+          end
+
+          # Sets the direct recv queue. Drains any messages that were
+          # buffered before the queue was available.
+          #
+          def direct_recv_queue=(queue)
+            @direct_recv_queue = queue
+            if queue && @pending_direct
+              @pending_direct.each do |msg|
+                queue.enqueue(msg)
+              end
+              @pending_direct = nil
+            end
           end
 
           # Sends a multi-frame message.
@@ -240,8 +254,11 @@ module OMQ
             if @direct_recv_queue
               msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
               @direct_recv_queue.enqueue(msg)
-            else
+            elsif @send_queue
               @send_queue.enqueue(parts)
+            else
+              msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
+              (@pending_direct ||= []) << msg
             end
           end
 

data/lib/omq/zmtp/transport/ipc.rb

@@ -32,7 +32,7 @@ module OMQ
               loop do
                 client = server.accept
                 Reactor.run do
-                  engine.handle_accepted(IO::Stream::Buffered.wrap(client, minimum_write_size: 0), endpoint: endpoint)
+                  engine.handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: endpoint)
                 rescue ProtocolError, *ZMTP::CONNECTION_LOST
                   # peer disconnected during handshake
                 rescue
@@ -57,7 +57,7 @@ module OMQ
             path = parse_path(endpoint)
             sock_path = to_socket_path(path)
             sock = UNIXSocket.new(sock_path)
-            engine.handle_connected(IO::Stream::Buffered.wrap(sock, minimum_write_size: 0), endpoint: endpoint)
+            engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
           end
 
           private

data/lib/omq/zmtp/transport/tcp.rb

@@ -29,7 +29,7 @@ module OMQ
               loop do
                 client = server.accept
                 Reactor.run do
-                  engine.handle_accepted(IO::Stream::Buffered.wrap(client, minimum_write_size: 0), endpoint: resolved)
+                  engine.handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: resolved)
                 rescue ProtocolError, *ZMTP::CONNECTION_LOST
                   # peer disconnected during handshake
                 rescue
@@ -53,7 +53,7 @@ module OMQ
           def connect(endpoint, engine)
             host, port = parse_endpoint(endpoint)
             sock = TCPSocket.new(host, port)
-            engine.handle_connected(IO::Stream::Buffered.wrap(sock, minimum_write_size: 0), endpoint: endpoint)
+            engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
           end
 
           private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.38'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '2.38'
 - !ruby/object:Gem::Dependency
   name: io-stream
   requirement: !ruby/object:Gem::Requirement
@@ -88,7 +88,7 @@ files:
 - lib/omq/zmtp/transport/tcp.rb
 - lib/omq/zmtp/valid_peers.rb
 - lib/omq/zmtp/writable.rb
-homepage: https://github.com/paddor/omq
+homepage: https://github.com/zeromq/omq
 licenses:
 - ISC
 metadata: {}