omq-cli 0.14.1 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5352d1d8bdbab1b64aa1e7a36afcc1c70619eb0ae8373d78e95c77669d6a4fec
-  data.tar.gz: 38172d3bbff810e3be322e3b8aa4e6d9e09520976d76b34e6721606dd8a15c95
+  metadata.gz: 23eb8d602298e5db1259e6d7d0effe08e8e0dfacba55b8d9a5287800290f2eb9
+  data.tar.gz: b492d78fd4997c82434853bc284f7f98c662d905a450e3545c1df2ae822bf40c
 SHA512:
-  metadata.gz: 158eb775b0ccea84275a69dc39e8279f41fab5f9bfeb94e8ca0c9e5dd7342b6472980e925850b7d82eceb509981942c42cd80abcb52a9e871b335075898a05b6
-  data.tar.gz: 8885731e2d99e87038bb6cffe9f4dc7edd480d285d4b2ac5b5f2244772433f70123e1ed49e9da7a9aa55944aab938bbbf10d7acc98975a04df6b45fd0a1d6b7c
+  metadata.gz: a3abd80d9856c52e2674c86a3e31ed4f02d6511cad2e3d9f35a2ab5b65faaf07acdc4c442f3746bc5ed0dd56e730df0fabc4930c0cdfe05ad8e289335fc0e8d4
+  data.tar.gz: 98e5cf25c2e267aace41bb958843459ead62da2a338b8a64aa3f6fc3af571dfefaee30b01a0de720b8880a96c6c0c3b55fe7a8439a6b5151a54085233ded3aaa

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.14.2 — 2026-04-13
+
+### Changed
+
+- `kill_on_protocol_error` is now a single
+  `SocketSetup.kill_on_protocol_error(sock, event)` class method.
+  Previously `BaseRunner`, `ParallelWorker`, and `PipeRunner` each
+  carried an identical 4-line copy of the CLI policy that
+  protocol-level disconnects mark the socket dead.
+- `ExpressionEvaluator.extract_block` is now a single class method
+  used by both the instance compile path and the
+  `compile_inside_ractor` path. The in-Ractor copy previously lived
+  as a local lambda that duplicated the instance
+  `extract_block` method.
+- `Formatter#encode` drops one String allocation per message on
+  the ascii / quoted / jsonl / marshal paths by mutating the
+  fresh `.join` / `JSON.generate` / `.inspect` result with `<<`
+  instead of `+ "\n"`.
+- `Formatter.marshal_preview` and `Formatter.frames_preview` (extracted
+  from `Formatter.preview` in the `-vvv` marshal trace work) are now
+  `private_class_method` — they were only ever meant to be called
+  through `Formatter.preview` but ended up on the public class surface.
+- Dropped a redundant unary `+` before `Formatter.sanitize(...)` in
+  `marshal_preview`: `sanitize` already returns a fresh mutable String
+  via `.tr`, so the `+""` dup was dead weight.
+- **`-vvv` marshal trace headers now show plaintext and wire byte
+  sizes.** Previously `<< (marshal) ...` carried no size info; it
+  now renders as `(135B marshal) ...` and, when ZMTP-Zstd
+  compression is negotiated, `(135B wire=50B marshal) ...` —
+  matching the frame-based preview format used by every other
+  `-vvv` output.
+  Other formats (ascii/quoted/jsonl/msgpack/raw) already showed
+  plaintext size via the frame preview; they now also pick up
+  `wire=NB` when compression is active, since `wire_size` is
+  side-channelled from `:message_sent` / `:message_received`
+  monitor events. Send-side `wire_size` is best-effort — the
+  engine's send pump emits the compressed byte count
+  asynchronously, so the value reflects the most recently
+  *completed* send; receive-side is exact.
+- Hot-path optimized.
+
 ## 0.14.1 — 2026-04-13
 
 ### Changed

data/lib/omq/cli/base_runner.rb

@@ -304,9 +304,19 @@ module OMQ
       # may write to stdout (e.g. `-e 'p it'`), and we want the
       # trace line to precede any such output so the sequence on the
       # terminal reads as: trace → eval side-effects → body.
+      #
+      # +@last_recv_wire_size+ is populated by the :message_received
+      # monitor event, which fires *before* the recv queue enqueue
+      # (recv_pump.rb) — so by the time @sock.receive returns here,
+      # the cache reflects this message. +@last_recv_uncompressed+
+      # is captured in #recv_msg from the raw marshal frame size.
       def trace_recv(parts)
         return unless config.verbose >= 3
-        $stderr.write("#{Term.log_prefix(config.timestamps)}omq: << #{Formatter.preview(parts, format: config.format)}\n")
+        preview = Formatter.preview(parts,
+                                    format:            config.format,
+                                    wire_size:         @last_recv_wire_size,
+                                    uncompressed_size: @last_recv_uncompressed)
+        $stderr.write("#{Term.log_prefix(config.timestamps)}omq: << #{preview}\n")
         $stderr.flush
       end
 
@@ -331,8 +341,9 @@ module OMQ
       def send_msg(parts)
         case config.format
         when :marshal
-          trace_send(parts)
-          @sock.send([Marshal.dump(parts)])
+          dumped = Marshal.dump(parts)
+          trace_send(parts, uncompressed_size: dumped.bytesize)
+          @sock.send([dumped])
         else
           return if parts.empty?
           trace_send(parts)
@@ -342,12 +353,21 @@ module OMQ
       end
 
 
-      # Symmetric to #trace_recv — log the outgoing message *before*
-      # Marshal.dump runs, so -M traces show the app-level object
-      # (`[nil, :foo, "bar"]`) instead of the wire-side dump bytes.
-      def trace_send(parts)
+      # Symmetric to #trace_recv — log the outgoing message using the
+      # pre-Marshal.dump +parts+, so -M traces show the app-level
+      # object (`[nil, :foo, "bar"]`) instead of the wire-side dump
+      # bytes. +@last_send_wire_size+ is best-effort: it reflects the
+      # *previous* message (populated by the :message_sent monitor
+      # event, which fires on a separate fiber after the pump writes),
+      # so early sends may show no `wire=` at all. Receive-side tracing
+      # is the authoritative path for observing wire bytes.
+      def trace_send(parts, uncompressed_size: nil)
         return unless config.verbose >= 3
-        $stderr.write("#{Term.log_prefix(config.timestamps)}omq: >> #{Formatter.preview(parts, format: config.format)}\n")
+        preview = Formatter.preview(parts,
+                                    format:            config.format,
+                                    wire_size:         @last_send_wire_size,
+                                    uncompressed_size: uncompressed_size)
+        $stderr.write("#{Term.log_prefix(config.timestamps)}omq: >> #{preview}\n")
         $stderr.flush
       end
 
@@ -355,7 +375,13 @@ module OMQ
       def recv_msg
         parts = @sock.receive
         return nil if parts.nil?
-        parts = Marshal.load(parts.first) if config.format == :marshal
+
+        case config.format
+        when :marshal
+          @last_recv_uncompressed = parts.first.bytesize
+          parts = Marshal.load(parts.first)
+        end
+
         transient_ready!
         parts
       end
@@ -499,37 +525,32 @@ module OMQ
       #   -vvv also log message sent/received traces
       # --timestamps[=s|ms|us]: prepend UTC timestamps to log lines
       #
-      # :message_received and :message_sent are intentionally skipped
-      # here and traced from BaseRunner#trace_recv / #trace_send
-      # instead — same fiber as the body write, so trace-then-body
+      # :message_received and :message_sent are not *logged* from the
+      # monitor fiber — #trace_recv / #trace_send render them inline
+      # on the same fiber as the body write, so trace-then-body
       # ordering is strict on a shared tty. The monitor-fiber path
       # suffered from $stderr/$stdout buffer races and from dumping
       # wire-side bytes (pre-Marshal.load on recv, post-Marshal.dump
-      # on send) instead of app-level parts.
-      SKIP_MONITOR_EVENTS = %i[message_received message_sent].freeze
+      # on send) instead of app-level parts. We still *observe* these
+      # events here to side-channel the compressed wire_size — for
+      # :message_received the event fires before the recv queue
+      # enqueue (engine/recv_pump.rb), so by the time @sock.receive
+      # returns, @last_recv_wire_size reflects the current message.
       def start_event_monitor
         trace      = config.verbose >= 3
         log_events = config.verbose >= 2
         @sock.monitor(verbose: trace) do |event|
-          Term.write_event(event, config.timestamps) if log_events && !SKIP_MONITOR_EVENTS.include?(event.type)
-          kill_on_protocol_error(event)
+          case event.type
+          when :message_received
+            @last_recv_wire_size = event.detail[:wire_size]
+          when :message_sent
+            @last_send_wire_size = event.detail[:wire_size]
+          else
+            Term.write_event(event, config.timestamps) if log_events
+          end
+          SocketSetup.kill_on_protocol_error(@sock, event)
         end
       end
-
-
-      # omq-cli policy: a peer that commits a protocol-level violation
-      # (Protocol::ZMTP::Error — oversized frame, decompression
-      # bytebomb, bad framing, …) is almost certainly a
-      # misconfiguration the user needs to see. Mark the socket dead
-      # so the next receive raises SocketDeadError. The library
-      # itself just drops the connection and keeps serving the
-      # others; this stricter policy is CLI-only.
-      def kill_on_protocol_error(event)
-        return unless event.type == :disconnected
-        error = event.detail && event.detail[:error]
-        return unless error.is_a?(Protocol::ZMTP::Error)
-        @sock.engine.signal_fatal_error(error)
-      end
     end
   end
 end

data/lib/omq/cli/expression_evaluator.rb

@@ -49,7 +49,7 @@ module OMQ
         return result if @format == :marshal
 
         result = result.is_a?(Array) ? result : [result]
-        result.map(&:to_s)
+        result.map { |part| part.to_s }
       rescue => e
         $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
         exit 3
@@ -67,7 +67,7 @@ module OMQ
         return nil if result.nil?
         return result if format == :marshal
         result = result.is_a?(Array) ? result : [result]
-        result.map(&:to_s)
+        result.map { |part| part.to_s }
       end
 
 
@@ -79,22 +79,8 @@ module OMQ
       def self.compile_inside_ractor(src)
         return [nil, nil, nil] unless src
 
-        extract = ->(expr, kw) {
-          s = expr.index(/#{kw}\s*\{/)
-          return [expr, nil] unless s
-          ci = expr.index("{", s)
-          depth = 1
-          j = ci + 1
-          while j < expr.length && depth > 0
-            depth += 1 if expr[j] == "{"
-            depth -= 1 if expr[j] == "}"
-            j += 1
-          end
-          [expr[0...s] + expr[j..], expr[(ci + 1)..(j - 2)]]
-        }
-
-        expr, begin_body = extract.(src, "BEGIN")
-        expr, end_body   = extract.(expr, "END")
+        expr, begin_body = extract_block(src,  "BEGIN")
+        expr, end_body   = extract_block(expr, "END")
 
         begin_proc = eval("proc { #{begin_body} }") if begin_body
         end_proc   = eval("proc { #{end_body} }")   if end_body
@@ -107,17 +93,13 @@ module OMQ
       end
 
 
-      private
-
-
-      def extract_blocks(expr)
-        expr, begin_body = extract_block(expr, "BEGIN")
-        expr, end_body   = extract_block(expr, "END")
-        [expr, begin_body, end_body]
-      end
-
-
-      def extract_block(expr, keyword)
+      # Strips a +BEGIN {...}+ or +END {...}+ block from +expr+ and
+      # returns +[trimmed_expr, block_body_or_nil]+. Brace-matched scan,
+      # so nested `{}` inside the block body are handled. Shared by
+      # instance and Ractor compile paths, so must be a class method
+      # (Ractors cannot call back into instance state).
+      #
+      def self.extract_block(expr, keyword)
         start = expr.index(/#{keyword}\s*\{/)
         return [expr, nil] unless start
 
@@ -138,6 +120,16 @@ module OMQ
         trimmed = expr[0...start] + expr[j..]
         [trimmed, body]
       end
+
+
+      private
+
+
+      def extract_blocks(expr)
+        expr, begin_body = self.class.extract_block(expr, "BEGIN")
+        expr, end_body   = self.class.extract_block(expr, "END")
+        [expr, begin_body, end_body]
+      end
     end
   end
 end

data/lib/omq/cli/formatter.rb

@@ -20,20 +20,20 @@ module OMQ
       def encode(parts)
         case @format
         when :ascii
-          parts.map { |p| p.b.gsub(/[^[:print:]\t]/, ".") }.join("\t") + "\n"
+          parts.map { |p| p.b.gsub(/[^[:print:]\t]/, ".") }.join("\t") << "\n"
         when :quoted
-          parts.map { |p| p.b.dump[1..-2] }.join("\t") + "\n"
+          parts.map { |p| p.b.dump[1..-2] }.join("\t") << "\n"
         when :raw
           parts.each_with_index.map do |p, i|
             Protocol::ZMTP::Codec::Frame.new(p.to_s, more: i < parts.size - 1).to_wire
           end.join
         when :jsonl
-          JSON.generate(parts) + "\n"
+          JSON.generate(parts) << "\n"
         when :msgpack
           MessagePack.pack(parts)
         when :marshal
           # Under -M, `parts` is a single Ruby object (not a frame array).
-          parts.inspect + "\n"
+          parts.inspect << "\n"
         end
       end
 
@@ -103,37 +103,65 @@ module OMQ
       # itself (not an Array of frames); the preview inspects it so
       # the reader sees the actual payload structure (e.g.
       # `[nil, :foo, "bar"]`) instead of a meaningless "1obj" header.
+      # For marshal, +uncompressed_size+ is the Marshal.dump bytesize
+      # (known to the caller, which already serialized for send or
+      # received the wire frame for recv) — passed through instead of
+      # redumping here.
       #
       # @param parts [Array<String, Object>, Object] message frames, or raw object when +format+ is :marshal
       # @param format [Symbol, nil] active CLI format (:marshal enables object-inspect mode)
       # @param wire_size [Integer, nil] compressed bytes on the wire
+      # @param uncompressed_size [Integer, nil] plaintext bytes (marshal only)
       # @return [String] truncated preview of each frame joined by |
-      def self.preview(parts, format: nil, wire_size: nil)
-        if format == :marshal
-          inspected = parts.inspect
-          truncated = inspected.bytesize > 60
-          inspected = inspected.byteslice(0, 60) if truncated
-          out = +"(marshal) #{sanitize(inspected)}"
-          out << "…" if truncated
-          return out
+      def self.preview(parts, format: nil, wire_size: nil, uncompressed_size: nil)
+        case format
+        when :marshal
+          marshal_preview(parts, uncompressed_size: uncompressed_size, wire_size: wire_size)
+        else
+          frames_preview(parts, format: format, wire_size: wire_size)
         end
+      end
+
+
+      def self.marshal_preview(parts, uncompressed_size:, wire_size:)
+        inspected = parts.inspect
+        truncated = inspected.bytesize > 60
+        inspected = inspected.byteslice(0, 60) if truncated
+        body      = sanitize(inspected)
+
+        body << "…" if truncated
+
+        header = case
+                 when uncompressed_size && wire_size
+                   "(#{uncompressed_size}B wire=#{wire_size}B marshal)"
+                 when uncompressed_size
+                   "(#{uncompressed_size}B marshal)"
+                 else
+                   "(marshal)"
+                 end
+
+        "#{header} #{body}"
+      end
+      private_class_method :marshal_preview
+
 
+      def self.frames_preview(parts, format:, wire_size:)
         nparts = parts.size
         shown  = parts.first(3).map { |p| preview_frame(p) }
         tail   = nparts > 3 ? "|…" : ""
-        total  = parts.all?(String) ? parts.sum(&:bytesize) : nil
-        size   =
-          if wire_size && total
-            "#{total}B wire=#{wire_size}B"
-          elsif total
-            "#{total}B"
-          else
-            "#{nparts}obj"
-          end
+        total  = parts.all?(String) ? parts.sum { |p| p.bytesize } : nil
+        size   = if wire_size && total
+                   "#{total}B wire=#{wire_size}B"
+                 elsif total
+                   "#{total}B"
+                 else
+                   "#{nparts}obj"
+                 end
         header = nparts > 1 ? "(#{size} #{nparts}F)" : "(#{size})"
 
         "#{header} #{shown.join("|")}#{tail}"
       end
+      private_class_method :frames_preview
 
 
       # Renders one frame or decoded object for {Formatter.preview}.

data/lib/omq/cli/parallel_worker.rb

@@ -70,22 +70,11 @@ module OMQ
         log_events = @config.verbose >= 2
         @sock.monitor(verbose: trace) do |event|
           @log_port.send(OMQ::CLI::Term.format_event(event, @config.timestamps)) if log_events
-          kill_on_protocol_error(event)
+          OMQ::CLI::SocketSetup.kill_on_protocol_error(@sock, event)
         end
       end
 
 
-      # Mirrors BaseRunner#kill_on_protocol_error: CLI-level policy
-      # that protocol-level disconnects kill the socket so the
-      # recv loop unblocks with SocketDeadError.
-      def kill_on_protocol_error(event)
-        return unless event.type == :disconnected
-        error = event.detail && event.detail[:error]
-        return unless error.is_a?(Protocol::ZMTP::Error)
-        @sock.engine.signal_fatal_error(error)
-      end
-
-
       def wait_for_peer
         if @config.timeout
           Fiber.scheduler.with_timeout(@config.timeout) do

data/lib/omq/cli/pipe.rb

@@ -203,18 +203,10 @@ module OMQ
         [@pull, @push].each do |sock|
           sock.monitor(verbose: trace) do |event|
             Term.write_event(event, config.timestamps) if log_events
-            kill_on_protocol_error(sock, event)
+            SocketSetup.kill_on_protocol_error(sock, event)
           end
         end
       end
-
-
-      def kill_on_protocol_error(sock, event)
-        return unless event.type == :disconnected
-        error = event.detail && event.detail[:error]
-        return unless error.is_a?(Protocol::ZMTP::Error)
-        sock.engine.signal_fatal_error(error)
-      end
     end
   end
 end

data/lib/omq/cli/socket_setup.rb

@@ -179,6 +179,24 @@ module OMQ
           $stderr.puts "OMQ_SERVER_KEY='#{Protocol::ZMTP::Z85.encode(server_pub)}'"
         end
       end
+
+
+      # CLI-level policy: a peer that commits a protocol-level violation
+      # (Protocol::ZMTP::Error — oversized frame, decompression bytebomb,
+      # bad framing, …) is almost certainly a misconfiguration the user
+      # needs to see. Mark +sock+ dead so the next receive raises
+      # SocketDeadError. The library itself just drops the connection and
+      # keeps serving the others; this stricter policy is CLI-only.
+      #
+      # @param sock [OMQ::Socket]
+      # @param event [OMQ::MonitorEvent]
+      #
+      def self.kill_on_protocol_error(sock, event)
+        return unless event.type == :disconnected
+        error = event.detail && event.detail[:error]
+        return unless error.is_a?(Protocol::ZMTP::Error)
+        sock.engine.signal_fatal_error(error)
+      end
     end
   end
 end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.14.1"
+    VERSION = "0.14.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -18,7 +18,7 @@ dependencies:
         version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.19.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.19.3
 - !ruby/object:Gem::Dependency
   name: omq-ffi
   requirement: !ruby/object:Gem::Requirement