omq-cli 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a558fd06799fcf4bee5d5036a4cac86c8482554df3998e5f42171d04e520db
-  data.tar.gz: e53bb5236bb5bc660e04ad00c10aa0f3b1e4a848ed9d74363c3943f877bf210f
+  metadata.gz: 23eb8d602298e5db1259e6d7d0effe08e8e0dfacba55b8d9a5287800290f2eb9
+  data.tar.gz: b492d78fd4997c82434853bc284f7f98c662d905a450e3545c1df2ae822bf40c
 SHA512:
-  metadata.gz: 5841f42d980388be4ce4d0feea88b76a358e86f6ba6e64f6b1775dfdcad16dc349ba3866c824fa74ffb88005876e64c027de9fd93fa21417c8a5a53be3180861
-  data.tar.gz: 4b68d2c56882c87a06e75fa348eff4f9df75d5cd0c3a85c26e20e6676780c61c0413e329dff7bdbb082b861795cdf09bb30aa4b61c7279c88bbd2e29373d1552
+  metadata.gz: a3abd80d9856c52e2674c86a3e31ed4f02d6511cad2e3d9f35a2ab5b65faaf07acdc4c442f3746bc5ed0dd56e730df0fabc4930c0cdfe05ad8e289335fc0e8d4
+  data.tar.gz: 98e5cf25c2e267aace41bb958843459ead62da2a338b8a64aa3f6fc3af571dfefaee30b01a0de720b8880a96c6c0c3b55fe7a8439a6b5151a54085233ded3aaa

data/CHANGELOG.md

@@ -1,5 +1,83 @@
 # 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
+
+- **`-M` (Marshal) now carries raw Ruby objects, not array-wrapped
+  frames.** Under `-M`, each wire frame is one Marshal-dumped Ruby
+  object; inside `-e` / `-E`, `it` is that object directly (not
+  `[object]`). Enables natural scalar/hash/custom-class flows:
+
+  ```sh
+  omq push -b tcp://:5557 -ME '"foo"'
+  omq pull -c tcp://:5557 -M -e '{it => it.encoding}'
+  # => {"foo" => #<Encoding:UTF-8>}
+  ```
+
+  The previous one-element-Array wrap was cosmetic — it always
+  produced exactly one wire frame anyway — so no multipart
+  semantics are lost.
+
+### Fixed
+
+- **`-vvv` trace lines now precede stdout side-effects from
+  `-e` / `-E`.** A `<<` / `>>` line is emitted from the app fiber
+  *before* the eval expression runs, so sequences like
+  `-e 'p it'` read strictly as `trace → eval output → body` on a
+  shared tty. Previous design emitted traces from the monitor
+  fiber and raced with stdout.
+- **`-vvv` under `-M` now shows the app-level object, not wire
+  bytes.** Preview header switches to `(marshal) <inspect>` with
+  sanitization and 60-byte truncation, e.g.
+  `<< (marshal) [nil, :foo, "bar"]`.
+- **`-vvv` trace preview sanitizes control characters.** Tabs,
+  newlines, CR, and backslash render as `\t`, `\n`, `\r`, `\\`;
+  other non-printables collapse to `.`. Previously raw LF inside
+  a binary frame could leak and break the single-line guarantee.
+- Test suite runs cleanly without protocol-error stderr noise.
+
 ## 0.14.0 — 2026-04-13
 
 ### Added

data/README.md

@@ -312,7 +312,7 @@ OMQ.outgoing { |msg| [*msg, Time.now.iso8601] }
 | `--raw` | Raw ZMTP binary (pipe to `hexdump -C` for debugging) |
 | `-J` / `--jsonl` | JSON Lines — `["frame1","frame2"]` per line |
 | `--msgpack` | MessagePack arrays (binary stream) |
-| `-M` / `--marshal` | Ruby Marshal (binary stream of `Array<String>` objects) |
+| `-M` / `--marshal` | Ruby Marshal — one arbitrary Ruby object per message |
 
 Multipart messages: in ASCII/quoted mode, frames are tab-separated. In JSONL mode,
 each message is a JSON array.
@@ -326,6 +326,20 @@ echo '["key","value"]' | omq push -c tcp://localhost:5557 -J
 omq pull -b tcp://:5557 -J
 ```
 
+Under `-M`, each wire frame is one Marshal-dumped Ruby object. Inside `-e` / `-E`,
+`it` is that raw object — not an Array of frames — so scalars, hashes, custom
+classes, or any Marshal-safe value flow through transparently:
+
+```sh
+# send a bare String, receive a { string => encoding } Hash
+omq push -b tcp://:5557 -ME '"foo"'
+omq pull -c tcp://:5557 -M -e '{it => it.encoding}'
+# => {"foo" => #<Encoding:UTF-8>}
+```
+
+At `-vvv`, trace lines for `-M` render the app-level object instead of wire
+bytes: `omq: >> (marshal) [nil, :foo, "bar"]`.
+
 ## Timing
 
 | Flag | Effect |

data/lib/omq/cli/base_runner.rb

@@ -266,6 +266,7 @@ module OMQ
           loop do
             parts = recv_msg
             break if parts.nil?
+            trace_recv(parts)
             parts = eval_recv_expr(parts)
             output(parts)
             i += 1
@@ -292,12 +293,34 @@ module OMQ
           @recv_tick_eof = true
           return 0
         end
+        trace_recv(parts)
         parts = eval_recv_expr(parts)
         output(parts)
         1
       end
 
 
+      # At -vvv, log the received message *before* eval runs. Eval
+      # 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
+        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
+
+
       def wait_for_loops(receiver, sender)
         if config.data || config.file || config.send_expr || config.recv_expr || config.target
           sender.wait
@@ -316,17 +339,49 @@ module OMQ
 
 
       def send_msg(parts)
-        return if parts.empty?
-        parts = [Marshal.dump(parts)] if config.format == :marshal
-        @sock.send(parts)
+        case config.format
+        when :marshal
+          dumped = Marshal.dump(parts)
+          trace_send(parts, uncompressed_size: dumped.bytesize)
+          @sock.send([dumped])
+        else
+          return if parts.empty?
+          trace_send(parts)
+          @sock.send(parts)
+        end
         transient_ready!
       end
 
 
+      # 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
+        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
+
+
       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
@@ -392,10 +447,6 @@ module OMQ
 
       def output(parts)
         return if config.quiet || parts.nil?
-        # At -vvv, the monitor fiber owns both the trace and the body
-        # output (see start_event_monitor). Skipping the app-side write
-        # avoids interleaving between the two fibers on a shared tty.
-        return if config.verbose >= 3
         $stdout.write(@fmt.encode(parts))
         $stdout.flush
       end
@@ -473,33 +524,33 @@ module OMQ
       #   -vv  log connect/disconnect/retry/timeout events
       #   -vvv also log message sent/received traces
       # --timestamps[=s|ms|us]: prepend UTC timestamps to log lines
+      #
+      # :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. 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
+        trace      = config.verbose >= 3
+        log_events = config.verbose >= 2
         @sock.monitor(verbose: trace) do |event|
-          Term.write_event(event, config.timestamps) if log_events
-          if trace && event.type == :message_received && !config.quiet
-            $stdout.write(@fmt.encode(event.detail[:parts]))
-            $stdout.flush
+          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
-          kill_on_protocol_error(event)
+          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/cli_parser.rb

@@ -123,6 +123,22 @@ module OMQ
           # multipart via tabs
           printf "routing-key\tpayload" | omq push --connect tcp://localhost:5557
 
+        -- Marshal (arbitrary Ruby objects) -------------------------
+
+          # With -M, each message on the wire is one Marshal-dumped
+          # Ruby object. Inside -e/-E, `it` is that raw object — not
+          # an Array of frames — so you can send/receive scalars,
+          # hashes, custom classes, whatever Marshal handles.
+
+          # send a bare string, receive a { string => encoding } hash
+          omq push -b tcp://:5557 -ME '"foo"'
+          omq pull -c tcp://:5557 -Mvvv -e '{it => it.encoding}'
+          # output: {"foo" => #<Encoding:UTF-8>}
+
+          # -vvv traces render the app object, not wire bytes
+          omq push -b tcp://:5557 -ME '{now: Time.now, pid: Process.pid}' -vvv
+          # >> (marshal) {now: 2026-04-13 ..., pid: 12345}
+
         -- Compression ----------------------------------------------
 
           # ZMTP-Zstd is negotiated transparently during the handshake.
@@ -344,7 +360,7 @@ module OMQ
           o.on(      "--raw",     "Raw binary, no framing")                     { opts[:format] = :raw }
           o.on("-J", "--jsonl",   "JSON Lines (array of strings per line)")     { opts[:format] = :jsonl }
           o.on(      "--msgpack",  "MessagePack arrays (binary stream)")         { require "msgpack"; opts[:format] = :msgpack }
-          o.on("-M", "--marshal", "Ruby Marshal stream (binary, Array<String>)") { opts[:format] = :marshal }
+          o.on("-M", "--marshal", "Ruby Marshal stream (one arbitrary object per message)") { opts[:format] = :marshal }
 
           o.separator "\nSubscription/groups:"
           o.on("-s", "--subscribe PREFIX", "Subscribe prefix (SUB, default all)")     { |v| opts[:subscribes] << v }

data/lib/omq/cli/expression_evaluator.rb

@@ -46,26 +46,28 @@ module OMQ
         result = context.instance_exec(parts, &@eval_proc)
         return nil  if result.nil?
         return SENT if result.equal?(context)
-        return [result] if @format == :marshal
+        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
       end
 
 
-      # Normalises an eval result to nil (skip) or an Array.
+      # Normalises an eval result to nil (skip), an Array (text formats),
+      # or an arbitrary Ruby object (+:marshal+).
+      #
       # Used inside Ractor worker blocks where instance methods are unavailable.
-      # When +format+ is :marshal, arbitrary objects are preserved (wrapped
-      # in a one-element Array so the wire path can Marshal.dump them).
+      # When +format+ is :marshal, the raw result is passed through — the
+      # wire path will Marshal.dump it into a single frame.
       #
       def self.normalize_result(result, format: nil)
         return nil if result.nil?
-        return [result] if format == :marshal
+        return result if format == :marshal
         result = result.is_a?(Array) ? result : [result]
-        result.map(&:to_s)
+        result.map { |part| part.to_s }
       end
 
 
@@ -77,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
@@ -105,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
 
@@ -136,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,19 +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
-          parts.map(&:inspect).join("\t") + "\n"
+          # Under -M, `parts` is a single Ruby object (not a frame array).
+          parts.inspect << "\n"
         end
       end
 
@@ -80,26 +81,102 @@ module OMQ
       end
 
 
+      # Whitespace/backslash → visible escape sequence used by
+      # {Formatter.sanitize}. Everything else outside printable ASCII
+      # collapses to '.' via a single String#tr call.
+      LINE_ESCAPES = {
+        "\t" => '\\t',
+        "\n" => '\\n',
+        "\r" => '\\r',
+        "\\" => '\\\\',
+      }.freeze
+
+
       # Formats message parts for human-readable preview (logging).
       # When +wire_size+ is given (ZMTP-Zstd negotiated), the header
       # also shows the compressed on-the-wire size: "(29B wire=12B)".
+      # Accepts either wire-side Array<String> (monitor events) or
+      # post-decode app parts that may contain non-String objects
+      # (e.g. -M Marshal.load output).
+      #
+      # When +format+ is +:marshal+, +parts+ is the raw Ruby object
+      # 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>] plaintext message frames
+      # @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, wire_size: nil)
-        total  = parts.sum(&:bytesize)
+      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 ? "|…" : ""
-        size   = wire_size ? "#{total}B wire=#{wire_size}B" : "#{total}B"
+        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}.
+      # Strings are sanitized byte-wise (first 12 bytes); non-String
+      # objects fall back to #inspect (always single-line) truncated
+      # at 24 bytes.
+      #
+      # @param part [String, Object]
+      # @return [String]
       def self.preview_frame(part)
+        unless part.is_a?(String)
+          s = part.inspect
+          return s.bytesize > 24 ? "#{s.byteslice(0, 24)}…" : s
+        end
+
         bytes = part.b
         # Empty frames must render as a visible marker, not as the empty
         # string — otherwise joining with "|" would produce misleading
@@ -113,11 +190,24 @@ module OMQ
         if printable < sample.bytesize / 2
           "[#{bytes.bytesize}B]"
         elsif bytes.bytesize > 12
-          "#{sample.gsub(/[^[:print:]]/, ".")}…"
+          "#{sanitize(sample)}…"
         else
-          sample.gsub(/[^[:print:]]/, ".")
+          sanitize(sample)
         end
       end
+
+
+      # Escapes bytes so a preview/body line is guaranteed single-line
+      # on a shared tty. Tab/newline/CR/backslash render as literal
+      # \t/\n/\r/\\; other non-printables collapse to '.'. Forced to
+      # binary encoding first to prevent UTF-8 quirks from rendering
+      # raw LF bytes.
+      #
+      # @param bytes [String]
+      # @return [String]
+      def self.sanitize(bytes)
+        bytes.b.gsub(/[\t\n\r\\]/, LINE_ESCAPES).tr("^ -~", ".")
+      end
     end
   end
 end

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/radio_dish.rb

@@ -11,10 +11,16 @@ module OMQ
 
 
       def send_msg(parts)
-        return if parts.empty?
-        parts = [Marshal.dump(parts)] if config.format == :marshal
-        group = config.group || parts.shift
-        @sock.publish(group, parts.first || "")
+        case config.format
+        when :marshal
+          trace_send(parts)
+          @sock.publish(config.group || "", Marshal.dump(parts))
+        else
+          return if parts.empty?
+          trace_send(parts)
+          group = config.group || parts.shift
+          @sock.publish(group, parts.first || "")
+        end
         transient_ready!
       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.0"
+    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.0
+  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