wslc-wip 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da7bb5fa632921c307adeeea727e792d38e688204393dfd3ee2c7759e40791b4
-  data.tar.gz: 2e2a277a4ab2dcf0ce540778b6263a142553430452905924f67158dc13ffed54
+  metadata.gz: be995c6781c440a7fd84dd3c3bbbddd6799154b59694edce5aa653d80c7d6e53
+  data.tar.gz: 7fb1638a125b2bce92212e8ff525a38e31e2d8aa4386e3e74e379420d4df9c91
 SHA512:
-  metadata.gz: f71156a19e193d0402f2fa4dc501aca0f32b27d63807c20b7a1a8dcddf1932f091af8ec12a0310aac36084a6c28034d843100abbf4adc3ac9c081d4e9304c18c
-  data.tar.gz: 538f842fd08441c9ec1603fc147d7c5ce7a5c6f2f2ce22edd0673b12709da19a6c23d3e7f1231a73d69d675337f09a17bc312aa07792308df414f1130e11b2a5
+  metadata.gz: 539721780baa7f366f215581629a761c85e396823e05ff08a3da97c2d0de7808d1470c959240867a5a0ab762f4441ea8b2cb22c92f0063712a18c6b0f80dc4fe
+  data.tar.gz: fc00ceceeeb01cd63ac931ff2ffeea1f64848f38a1222b60b8c5de7a501e914a3820d61abbd7d437ebd412e2046958223edab7b46d582b5cb6ef693badf5cc3e

data/README.md

@@ -148,14 +148,30 @@ exit, but the timestamp of the `+ ...` line tells you when wip finished its own
 off to `wslc`/`docker` — useful for telling wip-side overhead apart from time spent booting inside
 the container.
 
-While a step is still running, wip also prints a host resource snapshot (load average, memory
-used, and the top CPU-consuming processes) every 5 seconds, so a hang is visible even before the
-command has produced any output of its own:
+While a step is still running, wip also prints a host resource snapshot (load average, memory,
+disk I/O, and the top CPU-consuming processes) every 5 seconds, so a hang is visible even before
+the command has produced any output of its own:
 
 ```console
-wip: [debug] still running (load 3.42 2.10 1.05 | mem 6.1G/15.6G | top: wslc.exe(8842) cpu 61.0%/mem 3.2%, ...): running: wslc.exe exec -it -w /app app bin/rails c
+wip: [debug] still running (load 3.42 2.10 1.05 | mem 6.1G/15.6G | io read 12000KB/s write 400KB/s | top: wslc.exe(8842) cpu 61.0%/mem 3.2%, ...): running: wslc.exe exec -it -w /app app bin/rails c
 ```
 
+The disk I/O figure is worth watching first if the host's CPU and memory look idle — a slow
+`bundle`/`rails` boot is often WSL2's bind-mounted (`.:/app`-style) volumes doing a lot of small
+reads, not the container starving for CPU.
+
+For commands that hand the real terminal to the child (`-it`, e.g. `rails c`), these periodic
+snapshots go to a log file instead of your terminal — wip prints the path once at the start —
+since writing into a terminal the child controls in raw mode would garble both outputs. Commands
+that don't need a TTY still get the snapshots printed live.
+
+Override that choice with `--debug-log`:
+
+- `--debug-log=-` forces snapshots inline even for `-it` commands (only useful if you know your
+  terminal/pager can tolerate the interleaving).
+- `--debug-log=PATH` always writes snapshots to `PATH`, including for non-TTY commands, e.g. to
+  keep every run's snapshots in one place: `wip rails c --debug --debug-log=/tmp/wip-debug.log`.
+
 ## doctor
 
 Each check prints as `[OK]`, `[WARN]`, or `[FAIL]`. Warnings alone exit 0; a WSL2, interop, WSLC,

data/lib/wip/cli.rb

@@ -10,6 +10,7 @@ module Wip
   class CLI < Thor
     class_option :config, type: :string, desc: 'Path to wip.yml'
     class_option :debug, type: :boolean, default: false, desc: 'Print progress and timing for each step'
+    class_option :debug_log, type: :string, desc: 'Where --debug snapshots go: a file path, or "-" for inline'
     default_task :dispatch
 
     def self.exit_on_failure? = true
@@ -121,7 +122,7 @@ module Wip
 
     def execute(command, interactive: false, exit_on_failure: true)
       runner = CommandRunner.new(debug: debug?)
-      code = reporter.step("running: #{CommandDisplay.for_debug(command)}") do
+      code = reporter.step("running: #{CommandDisplay.for_debug(command)}", live: !interactive) do
         runner.run(command, interactive: interactive)
       end
       exit(code) if exit_on_failure && !code.zero?
@@ -143,7 +144,7 @@ module Wip
     end
 
     def debug? = options[:debug] || !ENV['WIP_DEBUG'].to_s.empty?
-    def reporter = @reporter ||= DebugReporter.new(enabled: debug?)
+    def reporter = @reporter ||= DebugReporter.new(enabled: debug?, log: options[:debug_log])
 
     def ensure_network
       network = load_config.network

data/lib/wip/debug_reporter.rb

@@ -1,27 +1,59 @@
 # frozen_string_literal: true
 
+require 'tmpdir'
+
 module Wip
   # Prints each step wip takes and how long it took, when debug mode is enabled.
   class DebugReporter
-    def initialize(enabled:, out: $stderr)
+    # `log:` overrides where resource snapshots go, regardless of `live`:
+    #   nil  - automatic (see `step`'s `live:`)
+    #   '-'  - always print inline, even for interactive steps
+    #   path - always write to this file, even for non-interactive steps
+    def initialize(enabled:, out: $stderr, log: nil)
       @enabled = enabled
       @out = out
+      @log = log
     end
 
-    def step(label)
+    # `live: false` is for steps that hand the real TTY to the child process
+    # (e.g. `wslc exec -it`). The child owns raw-mode cursor control there, so
+    # writing periodic snapshots straight into that same terminal races with
+    # it and garbles the output; those snapshots go to a log file instead,
+    # unless overridden by `log:` in the constructor.
+    def step(label, live: true)
       return yield unless @enabled
 
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @out.puts "wip: [debug] #{label}"
-      monitor = ResourceMonitor.new(out: @out)
+      file = log_file(live)
+      monitor = ResourceMonitor.new(out: file || @out)
       monitor.start(label)
       begin
         yield
       ensure
         monitor.stop
+        file&.close
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
         @out.puts format('wip: [debug] done in %<elapsed>.2fs: %<label>s', elapsed: elapsed, label: label)
       end
     end
+
+    private
+
+    def log_file(live)
+      return nil if @log == '-'
+      return open_log(@log, "streaming resource snapshots to #{@log}") if @log
+      return nil if live
+
+      path = File.join(Dir.tmpdir, "wip-debug-#{Process.pid}-#{Time.now.to_i}.log")
+      open_log(path, "command owns the terminal; streaming resource snapshots to #{path}")
+    end
+
+    def open_log(path, notice)
+      @out.puts "wip: [debug] #{notice}"
+      file = File.open(path, 'a') # rubocop:disable Style/FileOpen -- closed by `step`'s ensure block
+      file.sync = true
+      file
+    end
   end
 end

data/lib/wip/resource_monitor.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
 module Wip
-  # Periodically prints host CPU/memory/process info while a debug step is still
-  # running, so a hung or slow step is visible even before it produces output.
+  # Periodically prints host CPU/memory/disk-IO/process info while a debug step
+  # is still running, so a hung or slow step is visible even before it produces
+  # output of its own.
   class ResourceMonitor
     def initialize(interval: 5, out: $stderr)
       @interval = interval
       @out = out
+      @last_disk = disk_sectors
+      @last_sampled_at = monotonic
     end
 
     def start(label)
       @thread = Thread.new do
         loop do
           sleep @interval
-          @out.puts "wip: [debug] still running (#{load_average} | #{memory} | top: #{top_processes}): #{label}"
+          @out.puts "wip: [debug] still running (#{snapshot}): #{label}"
         end
       end
     end
@@ -25,6 +28,12 @@ module Wip
 
     private
 
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    def snapshot
+      [load_average, memory, disk_io, top_processes].join(' | ')
+    end
+
     def load_average
       "load #{File.read('/proc/loadavg').split[0..2].join(' ')}"
     rescue Errno::ENOENT, IOError
@@ -40,15 +49,46 @@ module Wip
       'mem n/a'
     end
 
+    # WSL2's bind-mounted (9p) volumes are often the real bottleneck behind a
+    # slow `bundle`/`rails` boot, and that shows up here rather than in CPU.
+    def disk_io
+      now = monotonic
+      elapsed = [now - @last_sampled_at, 0.001].max
+      current = disk_sectors
+      read_kbps = (current[:read] - @last_disk[:read]) * 0.5 / elapsed
+      write_kbps = (current[:write] - @last_disk[:write]) * 0.5 / elapsed
+      @last_disk = current
+      @last_sampled_at = now
+      format('io read %<read>.0fKB/s write %<write>.0fKB/s', read: read_kbps, write: write_kbps)
+    rescue Errno::ENOENT, IOError
+      'io n/a'
+    end
+
+    def disk_sectors
+      totals = { read: 0, write: 0 }
+      File.readlines('/proc/diskstats').each do |line|
+        fields = line.split
+        next if fields[2].to_s.match?(/\A(loop|ram)/)
+
+        totals[:read] += fields[5].to_i
+        totals[:write] += fields[9].to_i
+      end
+      totals
+    rescue Errno::ENOENT, IOError
+      { read: 0, write: 0 }
+    end
+
     def top_processes
-      `ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null`.lines.drop(1).first(3).filter_map do |line|
+      lines = `ps -eo pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null`.lines.drop(1).first(3)
+      entries = lines.filter_map do |line|
         pid, cpu, mem, comm = line.split(nil, 4)
         next unless comm
 
         "#{comm.strip}(#{pid}) cpu #{cpu}%/mem #{mem}%"
-      end.join(', ')
+      end
+      "top: #{entries.join(', ')}"
     rescue StandardError
-      'n/a'
+      'top: n/a'
     end
   end
 end

data/lib/wip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wip
-  VERSION = '0.4.2'
+  VERSION = '0.4.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Wip contributors