active_mutator 0.6.0 → 0.7.0

data/lib/active_mutator/scheduler.rb

@@ -8,43 +8,63 @@ module ActiveMutator
   class Scheduler
     OrphanedError = Class.new(Error)
 
+    # first_seq: phase-2 escalation runs on its own scheduler; starting its
+    # sequence after phase 1's keeps mutant numbers unique across the run.
     def initialize(jobs:, worker: Worker.method(:run), on_result: nil,
-                   calibrators: nil, orphaned: -> { Process.ppid == 1 })
+                   calibrators: nil, orphaned: -> { Process.ppid == 1 },
+                   events: Events.new, first_seq: 1, abort: AbortFlag.new)
+      @abort = abort
       @jobs = jobs
       @worker = worker
       @on_result = on_result
       @calibrators = calibrators
       @orphaned = orphaned
+      @events = events
+      @next_seq = first_seq
       @last_logged_scale = {} # lane => last scale logged for that lane
     end
 
+    # Signals are the Runner's: its AbortFlag trips, and the poll loop here
+    # kills every worker and raises Aborted with what finished.
     def run(items)
-      previous_traps = nil
       running = {}
-      previous_traps = install_signal_handlers(running)
       results = []
-      # Browser-covered mutants each boot Chrome + an app server; running them
-      # concurrently melts CPUs and manufactures false timeouts. Parallel lane
-      # first at full width, then the serial lane one at a time.
-      results.concat(run_pool(items.select { |i| i.lane == :parallel }, @jobs, running))
-      results.concat(run_pool(items.select { |i| i.lane == :serial }, 1, running))
+      @abort.deferred do
+        # Browser-covered mutants each boot Chrome + an app server; running
+        # them concurrently melts CPUs and manufactures false timeouts.
+        # Parallel lane first at full width, then the serial lane one at a time.
+        run_pool(items.select { |i| i.lane == :parallel }, @jobs, running, results)
+        run_pool(items.select { |i| i.lane == :serial }, 1, running, results)
+      end
       results
     ensure
-      restore_traps(previous_traps) if previous_traps
+      cleanup(running)
     end
 
     private
 
-    def run_pool(items, width, running)
+    def run_pool(items, width, running, results)
       queue = items.dup
-      results = []
       until queue.empty? && running.empty?
         abort_if_orphaned!(running)
-        spawn(queue.shift, running) while running.size < width && !queue.empty?
+        abort!(running, results) if @abort.tripped?
+        # A trip mid-fill stops the forking; the next pass kills what started.
+        spawn(queue.shift, running) while running.size < width && !queue.empty? && !@abort.tripped?
         reap(running, results)
         sleep 0.02 unless running.empty?
       end
-      results
+    end
+
+    # CI allows only seconds between SIGTERM and SIGKILL, so kill every
+    # worker group and move on without waiting for any of them.
+    def abort!(running, results)
+      in_flight = running.map do |pid, entry|
+        m = entry[:item].mutation
+        { seq: entry[:seq], pid: pid, subject: m.subject.name, file: m.subject.file, line: m.line,
+          description: m.description }
+      end
+      cleanup(running, wait: false)
+      raise Aborted.new(@abort.reason, results: results, in_flight: in_flight)
     end
 
     # SIGKILL on the parent (or a closed terminal, or CI teardown) cannot be
@@ -54,18 +74,27 @@ module ActiveMutator
     def abort_if_orphaned!(running)
       return unless @orphaned.call
 
-      running.each_key do |pid|
-        kill(pid)
-      rescue StandardError
+      raise OrphanedError, "parent process died; aborting mutation run"
+    end
+
+    def cleanup(running, wait: true)
+      running.each_key { |pid| signal_group(pid) }
+      running.each do |pid, entry|
+        entry[:reader].close
+        entry[:stderr_file].close!
+        Process.waitpid(pid) if wait
+      rescue Errno::ECHILD
         nil
       end
       running.clear
-      raise OrphanedError, "parent process died; aborting mutation run"
     end
 
     STDERR_TAIL_LINES = 20
 
     def spawn(item, running)
+      calibrator = calibrator_for(item)
+      budget = calibrator ? calibrator.budget_for(item) : item.timeout
+      log_scale(calibrator, item.lane)
       reader, writer = IO.pipe
       stderr_file = Tempfile.new("active_mutator-worker")
       pid = fork do
@@ -78,55 +107,86 @@ module ActiveMutator
         # harmless everywhere else.
         ENV["PGGSSENCMODE"] ||= "disable"
         @worker.call(item.mutation, item.example_ids, writer)
+        # A second line, after the worker's own report: the worker can exit
+        # between two memory samples, so it reports its peak itself.
+        writer.puts("", JSON.generate("peak_rss_kb" => MemoryProbe.peak_rss_kb))
         writer.close
         Process.exit!(0)
       end
       writer.close
-      calibrator = calibrator_for(item)
-      budget = calibrator ? calibrator.budget_for(item) : item.timeout
-      log_scale(calibrator, item.lane)
       started = now
+      seq = @next_seq
+      @next_seq += 1
       running[pid] = { reader: reader, item: item, started: started, stderr_file: stderr_file,
-                       budget: budget, deadline: started + budget }
+                       budget: budget, deadline: started + budget, seq: seq, payload: +"" }
+      emit_start(item, pid, seq, budget) if @events.listening?
+    ensure
+      unless pid
+        reader&.close
+        writer&.close
+        stderr_file&.close!
+      end
+    end
+
+    def emit_start(item, pid, seq, budget)
+      m = item.mutation
+      @events.emit(:mutant_start, seq: seq, pid: pid, lane: item.lane, budget: budget,
+                                  examples: item.example_ids.size, subject: m.subject.name,
+                                  file: m.subject.file, line: m.line, description: m.description)
     end
 
     def reap(running, results)
       running.to_a.each do |pid, entry|
-        done, _status = Process.waitpid2(pid, Process::WNOHANG)
-        if done
-          running.delete(pid)
+        # Read while the worker runs so a full pipe cannot prevent its exit.
+        # A descendant may retain the writer after that exit; keep the group
+        # tracked until EOF so aborts and the deadline still apply to it.
+        chunk = entry[:reader].read_nonblock(65_536, exception: false)
+        entry[:payload] << chunk if chunk.is_a?(String)
+        entry[:eof] = true if chunk.nil?
+        entry[:exited] ||= Process.waitpid(pid, Process::WNOHANG)
+        if entry[:exited] && entry[:eof]
           result = finish(entry)
-          if result.status == :killed
-            calibrator_for(entry[:item])&.record(now - entry[:started], entry[:budget])
-          end
-          results << result
+          calibrator_for(entry[:item])&.record(result.seconds, entry[:budget]) if result.status == :killed
+          results << complete(pid, entry, result)
+          running.delete(pid)
         elsif now > entry[:deadline]
           kill(pid)
-          running.delete(pid)
           entry[:reader].close
           entry[:stderr_file].close!
-          details = format("timed out after %.1fs (budget %.1fs)", now - entry[:started], entry[:budget])
-          results << report(Result.new(mutation: entry[:item].mutation, status: :timeout, details: details))
+          seconds = now - entry[:started]
+          details = format("timed out after %.1fs (budget %.1fs)", seconds, entry[:budget])
+          results << complete(pid, entry, Result.new(mutation: entry[:item].mutation, status: :timeout,
+                                                     details: details, seconds: seconds))
+          running.delete(pid)
         end
       end
     end
 
     def finish(entry)
-      payload = entry[:reader].read.to_s
+      seconds = now - entry[:started]
+      report_line, stats_line = entry[:payload].lines.map(&:strip).reject(&:empty?)
       entry[:reader].close
       stderr_tail = stderr_tail(entry[:stderr_file])
-      data = payload.empty? ? nil : JSON.parse(payload)
+      data = report_line && JSON.parse(report_line)
       # A self-mutation of Worker#emit can produce well-formed JSON without a
       # "status" key (or with a non-Hash root); treat any unusable payload as
       # a worker error instead of crashing the whole run.
       reported = data.is_a?(Hash) && data.key?("status")
       status = reported ? data["status"].to_sym : :error
       details = reported ? data["details"] : unreported_details(stderr_tail)
+      peak = JSON.parse(stats_line)["peak_rss_kb"] if stats_line
     rescue JSON::ParserError
-      report(Result.new(mutation: entry[:item].mutation, status: :error,
-                        details: "worker emitted unparseable payload"))
+      Result.new(mutation: entry[:item].mutation, status: :error,
+                 details: "worker emitted unparseable payload", seconds: seconds)
     else
-      report(Result.new(mutation: entry[:item].mutation, status: status, details: details))
+      Result.new(mutation: entry[:item].mutation, status: status, details: details,
+                 seconds: seconds, peak_rss_kb: peak)
+    end
+
+    def complete(pid, entry, result)
+      @events.emit(:mutant_end, seq: entry[:seq], pid: pid, status: result.status,
+                                seconds: result.seconds, peak_rss_kb: result.peak_rss_kb)
+      report(result)
     end
 
     def report(result)
@@ -149,14 +209,7 @@ module ActiveMutator
     end
 
     def kill(pid)
-      Process.kill("KILL", -pid) # negative pid = whole process group
-    rescue Errno::ESRCH, Errno::EPERM
-      # Group not established yet (setpgid race) or already gone: direct kill.
-      begin
-        Process.kill("KILL", pid)
-      rescue Errno::ESRCH
-        nil
-      end
+      signal_group(pid)
     ensure
       begin
         Process.waitpid(pid)
@@ -165,26 +218,17 @@ module ActiveMutator
       end
     end
 
-    # Returns {sig => previous_handler} so #run can restore on exit,
-    # otherwise our traps permanently replace the host's (e.g. RSpec's Ctrl-C).
-    def install_signal_handlers(running)
-      %w[INT TERM].to_h do |sig|
-        previous = trap(sig) do
-          running.each_key do |pid|
-            Process.kill("KILL", -pid)
-          rescue StandardError
-            nil
-          end
-          exit(130)
-        end
-        [sig, previous]
+    def signal_group(pid)
+      Process.kill("KILL", -pid) # negative pid = whole process group
+    rescue Errno::ESRCH, Errno::EPERM
+      # Group not established yet (setpgid race) or already gone: direct kill.
+      begin
+        Process.kill("KILL", pid)
+      rescue Errno::ESRCH
+        nil
       end
     end
 
-    def restore_traps(previous)
-      previous.each { |sig, handler| trap(sig, handler || "DEFAULT") }
-    end
-
     def calibrator_for(item)
       @calibrators && @calibrators[item.lane]
     end

data/lib/active_mutator/since_filter.rb

@@ -7,17 +7,32 @@ module ActiveMutator
 
     def self.parse(diff_text)
       changed = Hash.new { |h, k| h[k] = [] }
+      each_hunk(diff_text) do |file, start, count|
+        count.times { |i| changed[file] << start + i }
+      end
+      changed.reject { |_, lines| lines.empty? }
+    end
+
+    # New-side line each pure deletion follows (0 = top of file), per file.
+    # The deletion sits between that line and the next, so it is inside a
+    # subject only when the subject spans both.
+    def self.deletion_gaps(diff_text)
+      gaps = Hash.new { |h, k| h[k] = [] }
+      each_hunk(diff_text) do |file, start, count|
+        gaps[file] << start if count.zero?
+      end
+      gaps
+    end
+
+    def self.each_hunk(diff_text)
       current = nil
       diff_text.each_line do |line|
         if line.start_with?("+++ b/")
           current = line.delete_prefix("+++ b/").strip
         elsif current && (match = HUNK.match(line))
-          start = match[1].to_i
-          count = (match[2] || "1").to_i
-          count.times { |i| changed[current] << start + i }
+          yield current, match[1].to_i, (match[2] || "1").to_i
         end
       end
-      changed.reject { |_, lines| lines.empty? }
     end
 
     # Every file the diff touched on the new side, including deletion-only
@@ -29,7 +44,36 @@ module ActiveMutator
       end.uniq
     end
 
+    # Tokens that never change what the code does.
+    NOISE = %i[IGNORED_NEWLINE EMBDOC_BEGIN EMBDOC_LINE EMBDOC_END EOF].freeze
+
+    # True when two sources differ only in comments and blank lines. Magic
+    # comments (`# frozen_string_literal: true`) change behavior, so they
+    # count as code; so does anything that fails to parse.
+    def self.same_code?(old_source, new_source)
+      old_code = code_of(old_source)
+      !old_code.nil? && old_code == code_of(new_source)
+    end
+
+    def self.code_of(source)
+      result = Prism.parse_lex(source)
+      return nil if result.failure?
+
+      # A trailing comment swallows its line's newline, so comments become a
+      # newline instead of vanishing; runs of newlines collapse to one.
+      tokens = result.value.last.filter_map do |token, _state|
+        next if NOISE.include?(token.type)
+
+        %i[COMMENT NEWLINE].include?(token.type) ? :NEWLINE : [token.type, token.value]
+      end
+      tokens = tokens.chunk_while { |a, b| a == :NEWLINE && b == :NEWLINE }.map(&:first)
+      tokens.shift if tokens.first == :NEWLINE
+      tokens.pop if tokens.last == :NEWLINE
+      [tokens, result.magic_comments.map { |c| [c.key, c.value] }]
+    end
+
     def initialize(ref:, root:)
+      @ref = ref
       @root = root
       diff = IO.popen(
         ["git", "-C", root, "diff", "--unified=0", ref, "--", "*.rb"], &:read
@@ -37,6 +81,7 @@ module ActiveMutator
       raise Error, "git diff #{ref} failed" unless $?.success?
 
       @changed = self.class.parse(diff)
+      @gaps = self.class.deletion_gaps(diff)
       @touched = self.class.touched_files(diff)
       untracked = IO.popen(
         ["git", "-C", root, "ls-files", "--others", "--exclude-standard", "--", "*.rb"], &:read
@@ -53,12 +98,28 @@ module ActiveMutator
     # further git calls.
     def changed_files = @touched
 
+    # Whether a changed file's edits since the ref are only comments. Reads
+    # the old side with `git show`; a file missing there (untracked, renamed)
+    # prints nothing, so it compares against an empty source and any code in
+    # it counts.
+    def comment_only?(path)
+      old_source = IO.popen(["git", "-C", @root, "show", "#{@ref}:#{path}"], err: File::NULL, &:read)
+      self.class.same_code?(old_source, File.read(File.join(@root, path)))
+    end
+
+    # Whether the file only lost lines since the ref: touched, but with no
+    # added or changed lines (untracked files count as all added).
+    def deletion_only?(path) = !@changed.key?(path)
+
     def cover?(subject)
-      lines = @changed[subject.file.delete_prefix("#{@root}/")]
-      return false unless lines
+      rel = subject.file.delete_prefix("#{@root}/")
+      lines = @changed[rel]
       return true if lines == :all
 
-      lines.any? { |line| subject.line_range.cover?(line) }
+      range = subject.line_range
+      return true if lines&.any? { |line| range.cover?(line) }
+
+      @gaps.fetch(rel, []).any? { |gap| range.cover?(gap) && range.cover?(gap + 1) }
     end
   end
 end

data/lib/active_mutator/version.rb

@@ -1,3 +1,3 @@
 module ActiveMutator
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/active_mutator.rb

@@ -25,6 +25,11 @@ require_relative "active_mutator/operators/negation_removal"
 require_relative "active_mutator/mutation"
 require_relative "active_mutator/analysis"
 require_relative "active_mutator/engine"
+require_relative "active_mutator/abort_flag"
+require_relative "active_mutator/memory_ceiling"
+require_relative "active_mutator/events"
+require_relative "active_mutator/diagnostics/text"
+require_relative "active_mutator/diagnostics/ndjson"
 require_relative "active_mutator/atomic_file"
 require_relative "active_mutator/coverage_map"
 require_relative "active_mutator/baseline"
@@ -32,6 +37,8 @@ require_relative "active_mutator/baseline_delta"
 require_relative "active_mutator/defined_constants"
 require_relative "active_mutator/inserter"
 require_relative "active_mutator/closure_reload"
+require_relative "active_mutator/memory_probe"
+require_relative "active_mutator/sampler"
 require_relative "active_mutator/worker"
 require_relative "active_mutator/result"
 require_relative "active_mutator/work_item"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mutator
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Daniel John
@@ -70,6 +70,7 @@ files:
 - README.md
 - exe/active_mutator
 - lib/active_mutator.rb
+- lib/active_mutator/abort_flag.rb
 - lib/active_mutator/accepted_ledger.rb
 - lib/active_mutator/analysis.rb
 - lib/active_mutator/atomic_file.rb
@@ -83,10 +84,15 @@ files:
 - lib/active_mutator/config_file.rb
 - lib/active_mutator/coverage_map.rb
 - lib/active_mutator/defined_constants.rb
+- lib/active_mutator/diagnostics/ndjson.rb
+- lib/active_mutator/diagnostics/text.rb
 - lib/active_mutator/edit.rb
 - lib/active_mutator/engine.rb
+- lib/active_mutator/events.rb
 - lib/active_mutator/fingerprint.rb
 - lib/active_mutator/inserter.rb
+- lib/active_mutator/memory_ceiling.rb
+- lib/active_mutator/memory_probe.rb
 - lib/active_mutator/mutation.rb
 - lib/active_mutator/operators/base.rb
 - lib/active_mutator/operators/call_swap.rb
@@ -104,6 +110,7 @@ files:
 - lib/active_mutator/reporter/terminal.rb
 - lib/active_mutator/result.rb
 - lib/active_mutator/runner.rb
+- lib/active_mutator/sampler.rb
 - lib/active_mutator/scheduler.rb
 - lib/active_mutator/since_filter.rb
 - lib/active_mutator/source_location.rb