fun_ci 2.0.0-arm64-darwin

data/lib/fun_ci/evidence/detection.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "presets"
+require_relative "line_scan"
+require_relative "patterns"
+require_relative "source"
+
+module FunCi
+  module Evidence
+    # Which presets run when a stage fails (architecture.md, "Evidence of a failed stage").
+    # When it starts, the candidates: presets any of whose marker files the
+    # worktree has (a marker may also name a text the file must hold), and
+    # presets without markers. When it fails, of the candidates with an
+    # output signature, those whose signature matched a line of the output's
+    # last megabyte, where tools print their summaries: each signature costs
+    # a read, and over the whole window with every preset a candidate that
+    # was most of the budget (script/bench_detection.rb). The part is read
+    # once, against the signatures joined.
+    module Detection
+      # because: why it was chosen, such as "file Gemfile", or nil.
+      Found = Data.define(:preset, :because)
+      SCAN_BYTES = 1_048_576
+
+      def self.candidates(worktree, presets)
+        presets.filter_map do |preset|
+          next Found.new(preset: preset, because: nil) if preset.markers.empty?
+
+          file = preset.markers.lazy.filter_map { |marker| marked(worktree, marker) }.first
+          file && Found.new(preset: preset, because: "file #{file}")
+        end
+      end
+
+      def self.chosen(output, candidates, deadline, scan_bytes: SCAN_BYTES)
+        last_part = output.byteslice([output.bytesize - scan_bytes, 0].max..)
+        seen = SignatureScan.new(candidates.map(&:preset)).seen(Source.of("output", last_part).lines, deadline)
+        candidates.filter_map { |found| chose(found, seen) }
+      end
+
+      def self.chose(found, seen)
+        return found unless found.preset.signature
+
+        matched = seen[found.preset.name]
+        matched && found.with(because: [found.because, "output matched #{matched.inspect}"].compact.join(", "))
+      end
+
+      # The file that bears the marker out, or nil. A marker is a path or a
+      # glob, or { path, contains } for a file that must hold a text.
+      def self.marked(worktree, marker)
+        return worktree.glob(marker).first if marker.is_a?(String)
+
+        path = marker["path"]
+        path if worktree.exist?(path) && worktree.read(path).include?(marker["contains"])
+      end
+      private_class_method :chose, :marked
+    end
+
+    # Reads lines once against a set of presets' signatures joined into one
+    # pattern; a line the joined pattern matches is tried against each
+    # signature, since a joined pattern reports one of those that match.
+    class SignatureScan
+      def initialize(presets)
+        @signatures = presets.select(&:signature).to_h { |preset| [preset.name, Regexp.new(preset.signature)] }
+        @joined = Patterns.compile(@signatures.values.map { |pattern| "(?:#{pattern.source})" }.join("|")).first
+      end
+
+      # The first text each signature matched, by preset name.
+      def seen(lines, deadline)
+        seen = {}
+        return seen if @signatures.empty?
+
+        LineScan.cut_short?(lines, deadline) { |line, _| note(seen, line) if @joined.match?(line) }
+        seen
+      end
+
+      private
+
+      def note(seen, line)
+        @signatures.each { |name, pattern| seen[name] ||= pattern.match(line)&.[](0) }
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/document.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FunCi
+  module Evidence
+    # What fun-ci kept about why a stage failed (architecture.md, "Evidence of a failed stage"): the extractors
+    # chosen and why, facts, failures, excerpts, and the problems extractors
+    # had. Each item is a hash naming the extractor that found it.
+    Document = Data.define(:chosen, :facts, :failures, :excerpts, :problems)
+
+    class Document
+      TAIL_TITLE = "The output's last lines"
+
+      # A document as fun-ci kept it; a list it doesn't have is empty.
+      def self.from_json(text)
+        parsed = JSON.parse(text, symbolize_names: true)
+        new(**members.to_h { |member| [member, parsed.fetch(member, [])] })
+      end
+
+      # The evidence from each extractor's findings, [name, findings] in the
+      # order they are shown, each item crediting the extractor that found
+      # it; the same failure found twice is kept where it was found first.
+      def self.assemble(parts, problems:, chosen:)
+        failures = credited(parts, :failures).uniq { |failure| failure.values_at(:test, :file, :line) }
+        new(chosen: chosen, facts: credited(parts, :facts), failures: failures,
+            excerpts: credited(parts, :excerpts), problems: problems)
+      end
+
+      def self.credited(parts, list)
+        parts.flat_map { |name, found| found.public_send(list).map { |item| item.merge(extractor: name) } }
+      end
+
+      # The evidence of a stage whose collecting went wrong: what went wrong.
+      def self.broken(message)
+        new(chosen: [], facts: [], failures: [], excerpts: [],
+            problems: [{ extractor: "fun-ci", message: "couldn't collect the evidence: #{message}" }])
+      end
+
+      # The evidence of a row an older fun-ci kept: the output's tail, and the
+      # failures its stage's reports named.
+      def self.legacy(tail:, failures:)
+        new(chosen: [], facts: [], failures: failures.map { |failure| failure.merge(extractor: "test-reports") },
+            excerpts: tail ? [tail_excerpt(tail)] : [], problems: [])
+      end
+
+      # The output's last lines as output-tail kept them, or nil.
+      def tail
+        excerpt = excerpts.find { |candidate| candidate[:extractor] == "output-tail" }
+        excerpt && excerpt[:lines].map { |line| "#{line}\n" }.join
+      end
+
+      def self.tail_excerpt(tail)
+        { title: TAIL_TITLE, location: "output", lines: tail.lines(chomp: true), extractor: "output-tail" }
+      end
+      private_class_method :tail_excerpt, :credited
+    end
+  end
+end

data/lib/fun_ci/evidence/extract_command.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+require "tmpdir"
+require_relative "extract_options"
+require_relative "saved_run"
+require_relative "collector"
+require_relative "command_runner"
+require_relative "worktree"
+require_relative "../agent/stage_summary"
+require_relative "../agent/evidence_text"
+require_relative "../agent/report_stage"
+
+module FunCi
+  module Evidence
+    # `fun-ci extract STAGE --output FILE` (acceptance-tests.md, AT-10.16):
+    # runs a stage's extractors against a saved output, with the current
+    # directory as the worktree, and prints what `why` would print, touching
+    # no database, so a project can try an extractor without a commit.
+    class ExtractCommand
+      NO_START = { name: "start sizes",
+                   value: "none, so files are read whole and every watched file counts as changed" }.freeze
+      NO_GROUP = { name: "process group", value: "none, so entries with on: overrun don't run" }.freeze
+
+      def initialize(dir, io)
+        @dir = dir
+        @io = io
+      end
+
+      def run(args)
+        options = ExtractOptions.parse(args)
+        document = Dir.mktmpdir("fun-ci-extract") { |scratch| collect(options, scratch) }
+        options.json ? print_json(options, document) : print_text(options, document)
+        0
+      rescue ExtractOptions::Invalid => e
+        @io.stderr.puts "fun-ci extract: #{e.message}"
+        64
+      end
+
+      private
+
+      def collect(options, scratch)
+        sources = Sources.new(stage: options.stage, worktree: @dir, stage_dir: SavedRun.new(scratch),
+                              environment: ENV.to_h)
+        collector = Collector.new(sources, settings: Settings.load(File.join(@dir, ".fun-ci", "config")),
+                                           commands: CommandRunner.new(dir: @dir, scratch: scratch))
+        noted(collector.collect(output(options), outcome(options)), options)
+      end
+
+      # The saved output, a path from the project or an absolute one.
+      def output(options)
+        path = File.expand_path(options.output, @dir)
+        Worktree.new(File.dirname(path)).read(File.basename(path))
+      rescue SystemCallError => e
+        raise ExtractOptions::Invalid, "can't read #{options.output}: #{e.message.sub(/ @ .*/, "")}"
+      end
+
+      def state(options) = options.timed_out ? "over_budget" : "failed"
+
+      def outcome(options)
+        Outcome.new(state: state(options), exit_status: options.timed_out ? nil : options.exit_status)
+      end
+
+      def noted(document, options)
+        notes = [NO_START, *(options.timed_out ? [NO_GROUP] : [])]
+        notes = notes.map { |fact| fact.merge(extractor: "fun-ci extract") }
+        document.with(facts: notes + document.facts)
+      end
+
+      def print_text(options, document)
+        stage = Agent::RunReport::Stage.new(name: options.stage, state: state(options), seconds: nil,
+                                            exit: Agent::RunReport::Exit.new(exit_status: outcome(options).exit_status,
+                                                                             signal: nil, budget: nil))
+        [Agent::StageSummary.line(stage), *Agent::EvidenceText.lines(document)].each { |line| @io.stdout.puts line }
+      end
+
+      def print_json(options, document)
+        @io.stdout.puts JSON.generate({ schema: 1, stage: options.stage, state: state(options),
+                                        exit_status: outcome(options).exit_status, evidence: document.to_h })
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extract_options.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module FunCi
+  module Evidence
+    # The arguments of `fun-ci extract STAGE --output FILE [--exit N |
+    # --timed-out] [--json]`.
+    module ExtractOptions
+      class Invalid < StandardError; end
+
+      Parsed = Data.define(:stage, :output, :exit_status, :timed_out, :json)
+      STAGES = %w[lint build fast slow].freeze
+      DEFAULTS = { output: nil, exit_status: 1, timed_out: false, json: false }.freeze
+
+      SWITCHES = { output: ["--output FILE"], exit_status: ["--exit N", Integer], timed_out: ["--timed-out"],
+                   json: ["--json"] }.freeze
+
+      def self.parse(args)
+        values = DEFAULTS.dup
+        stages = parser(values).parse(args)
+        raise Invalid, "--output FILE names the saved output to read" unless values[:output]
+
+        Parsed.new(stage: one_stage(stages), **values)
+      rescue OptionParser::ParseError => e
+        raise Invalid, e.message
+      end
+
+      def self.one_stage(stages)
+        return stages.first if stages.size == 1 && STAGES.include?(stages.first)
+
+        raise Invalid, "name one stage of #{STAGES.join(", ")}, not #{stages.join(" ")}"
+      end
+
+      # A switch without an argument sets its value to true.
+      def self.parser(values)
+        parser = OptionParser.new
+        parser.base.long.clear
+        SWITCHES.each { |key, switch| parser.on(*switch) { |value| values[key] = value } }
+        parser
+      end
+      private_class_method :one_stage, :parser
+    end
+  end
+end

data/lib/fun_ci/evidence/extraction.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "catalog"
+require_relative "problem"
+
+module FunCi
+  module Evidence
+    # Runs a stage's entries in order within the budget: an entry that is
+    # mistaken, raises, or comes after the deadline is a problem, and the
+    # others still run.
+    class Extraction
+      # parts: [[name, findings], ...] in order; chosen: [{ extractor:, because: }].
+      Result = Data.define(:parts, :problems, :chosen)
+      # An entry that ran; one that didn't is a problem, { extractor:, message: }.
+      Ran = Data.define(:name, :findings, :because)
+
+      def initialize(context, budget)
+        @context = context
+        @budget = budget
+      end
+
+      # raw_entries: [[raw entry, why it was chosen], ...]
+      def run(raw_entries)
+        ran, problems = raw_entries.map { |raw, because| attempt(raw, because) }.partition { |done| done.is_a?(Ran) }
+        Result.new(parts: ran.map { |done| [done.name, done.findings] }, problems: problems,
+                   chosen: ran.map { |done| { extractor: done.name, because: done.because } })
+      end
+
+      private
+
+      def attempt(raw, because)
+        entry = Catalog.entry(raw)
+        return failed(entry.name, "not run: the evidence budget of #{@budget}s ran out") if @context.deadline.passed?
+
+        ran(entry, because)
+      rescue Catalog::Refused => e
+        failed(label(raw), e.message)
+      end
+
+      # Whatever an extractor raises is a problem, never the end of the evidence.
+      def ran(entry, because)
+        Ran.new(name: entry.name, findings: entry.extractor.extract(@context), because: because)
+      rescue Problem => e
+        failed(entry.name, e.message)
+      rescue StandardError => e
+        failed(entry.name, "#{e.class}: #{e.message}")
+      end
+
+      def failed(name, message) = { extractor: name, message: message }
+
+      def label(raw) = raw.is_a?(Hash) ? raw["use"] || "run:#{raw["run"]}" : raw.to_s
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/command.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../command_output"
+require_relative "../context_document"
+require_relative "../problem"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # A project's own extractor, a `run:` entry: the command, run in the
+      # worktree with what is left of the budget, reads the context on stdin
+      # and prints evidence as text or, with `format: json`, as a document
+      # (architecture.md, "Evidence of a failed stage"). `watch` names the files it is told
+      # about; whatever else the entry says is passed on as `options`.
+      class Command
+        OWN = %w[run format watch].freeze
+        STDERR_LINES = 20
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context)
+          ran = context.commands.call(@options["run"], stdin: JSON.generate(document(context)),
+                                                       seconds: context.deadline.left, env: group(context))
+          refuse(ran)
+          return CommandOutput.json(ran.stdout) if @options["format"] == "json"
+
+          CommandOutput.text(@options["run"], ran.stdout)
+        end
+
+        private
+
+        # Run before the kill of a stage over budget, it is told the stage's group.
+        def group(context) = context.pgid ? { "FUN_CI_PGID" => context.pgid.to_s } : {}
+
+        def document(context)
+          ContextDocument.for(context.about, context, watch: Array(@options["watch"]), options: @options.except(*OWN))
+        end
+
+        def refuse(ran)
+          raise Problem, "killed: still running when the evidence budget ran out" if ran.killed == :budget
+          raise Problem, "killed: printed more than 256 KB" if ran.killed == :overflow
+          raise Problem, "exited #{ran.exit_status}: #{last_lines(ran.stderr)}" unless ran.exit_status.zero?
+        end
+
+        def last_lines(stderr) = stderr.lines(chomp: true).last(STDERR_LINES).join("\n")
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/grep.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+require_relative "../source"
+require_relative "../line_scan"
+require_relative "../patterns"
+require_relative "../line_ranges"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `grep`: the lines of the output, or of a file, that match any of
+      # `patterns`, with `context` lines around each; matches whose context
+      # meets are one excerpt.
+      class Grep
+        OPTIONS = { "patterns" => :patterns, "context" => :count, "path" => :path, "title" => :word }.freeze
+        REQUIRED = %w[patterns].freeze
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context) = found_in(Source.for(context, @options["path"]), context.deadline)
+
+        def found_in(source, deadline)
+          hits, truncated = matches(source.lines, deadline)
+          ranges = LineRanges.around(hits, @options.fetch("context", 0), source.lines.size)
+          Findings.new(excerpts: ranges.map { |range| excerpt(source, range, truncated) })
+        end
+
+        private
+
+        def matches(lines, deadline)
+          patterns = Patterns.compile(@options["patterns"])
+          hits = []
+          truncated = LineScan.cut_short?(lines, deadline) do |line, index|
+            hits << index if patterns.any? { |pattern| pattern.match?(line) }
+          end
+          [hits, truncated]
+        end
+
+        def excerpt(source, range, truncated)
+          { title: @options.fetch("title") { "Lines matching #{Array(@options["patterns"]).join(" or ")}" },
+            location: source.location(range.first, range.last), lines: source.lines[range], truncated: truncated }
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/json_log.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+require_relative "../source"
+require_relative "../line_scan"
+require_relative "../log_record"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `json-log`: the JSON log lines of the output, or of a file, at or
+      # above `level` (warn by default), each as one line (time, level,
+      # logger, message) followed by its stack trace. A preset names a
+      # logging setup's `fields`, such as logstash's.
+      class JsonLog
+        OPTIONS = { "path" => :path, "level" => :level, "fields" => :fields, "levels" => :levels }.freeze
+        REQUIRED = %w[fields].freeze
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context)
+          source = Source.for(context, @options["path"])
+          kept = []
+          truncated = LineScan.cut_short?(source.lines, context.deadline) { |line, index| keep(kept, line, index) }
+          Findings.new(excerpts: kept.empty? ? [] : [excerpt(source, kept, truncated)])
+        end
+
+        private
+
+        def keep(kept, line, index)
+          record = LogRecord.parse(line, @options["fields"], @options.fetch("levels", {}))
+          kept << [index, record.lines] if record&.at_least?(LogRecord.rank(@options.fetch("level", "warn")))
+        end
+
+        def excerpt(source, kept, truncated)
+          { title: "Log records at #{@options.fetch("level", "warn")} or above",
+            location: source.location(kept.first.first, kept.last.first), lines: kept.flat_map(&:last),
+            truncated: truncated }
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/junit_files.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+require_relative "../../pipeline/test_report"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `junit-files`: the failures in the JUnit XML under `paths` that the
+      # stage wrote, where a build tool keeps its own reports
+      # (target/surefire-reports/*.xml, build/test-results/**/*.xml).
+      class JunitFiles
+        OPTIONS = { "paths" => :globs }.freeze
+        REQUIRED = %w[paths].freeze
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context)
+          written = globs.flat_map { |glob| context.worktree.glob(glob) }.uniq
+                         .reject { |path| context.watched[path] == context.worktree.stamp(path) }
+          Findings.new(failures: written.flat_map do |path|
+            Pipeline::TestReport.junit(context.worktree.read(path)) || []
+          end)
+        end
+
+        def globs = Array(@options["paths"])
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/last_lines.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # The last `count` lines of a source, as one excerpt.
+      class LastLines
+        def initialize(count)
+          @count = count
+        end
+
+        def found_in(source, _deadline)
+          return Findings.new if source.lines.empty?
+
+          first = [source.lines.size - @count, 0].max
+          Findings.new(excerpts: [{ title: "What the stage wrote to #{source.name}",
+                                    location: source.location(first, source.lines.size - 1),
+                                    lines: source.lines[first..], truncated: first.positive? }])
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/log_file.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+require_relative "../source"
+require_relative "grep"
+require_relative "section"
+require_relative "last_lines"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `log-file`: what the stage wrote to the files under `path`, read from
+      # the size each had when it started; whole, for one it created, or one
+      # rewritten (no longer, or a new inode), which the fact `truncated`
+      # names. Filtered by `grep` or by a section from `start`, when given,
+      # else its last `lines`.
+      class LogFile
+        OPTIONS = { "path" => :path, "grep" => :patterns, "context" => :count, "start" => :patterns,
+                    "end" => :patterns, "lines" => :count }.freeze
+        REQUIRED = %w[path].freeze
+        LINES = 200
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context)
+          changed = context.worktree.glob(@options["path"]).reject { |path| unchanged?(context, path) }
+          found = changed.map { |path| written(context, path) }
+          Findings.new(facts: changed.select { |path| rewritten?(context, path) }.map { |path| truncated(path) },
+                       excerpts: found.flat_map(&:excerpts))
+        end
+
+        private
+
+        def truncated(path) = { name: "truncated", value: path }
+        def unchanged?(context, path) = context.watched[path] == context.worktree.stamp(path)
+
+        # Changed without growing, or replaced by another file.
+        def rewritten?(context, path)
+          before = context.watched[path]
+          now = context.worktree.stamp(path)
+          !before.nil? && (now.size <= before.size || now.inode != before.inode)
+        end
+
+        def written(context, path)
+          from = rewritten?(context, path) ? 0 : context.watched[path]&.size.to_i
+          source = Source.of(path, context.worktree.read(path, from: from),
+                             skipped: context.worktree.lines_before(path, from))
+          filter.found_in(source, context.deadline)
+        end
+
+        def filter
+          return Grep.new(@options.slice("context").merge("patterns" => @options["grep"])) if @options["grep"]
+          return Section.new(@options.slice("start", "end", "lines")) if @options["start"]
+
+          LastLines.new(@options.fetch("lines", LINES))
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/extractors/process_tree.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../findings"
+
+module FunCi
+  module Evidence
+    module Extractors
+      # `process-tree`: for a stage that ran over budget, before the kill, the
+      # processes of its group as a tree, each with how long it had run, and
+      # the deepest one as the fact `running` (architecture.md, "Evidence of a failed stage").
+      class ProcessTree
+        OPTIONS = {}.freeze
+        REQUIRED = [].freeze
+
+        def initialize(options)
+          @options = options
+        end
+
+        def extract(context)
+          return Findings.new unless context.pgid
+
+          group = context.processes.call.select { |row| row.pgid == context.pgid }
+          return Findings.new if group.empty?
+
+          Findings.new(facts: [running(group)], excerpts: [tree(group)])
+        end
+
+        private
+
+        def depth(row, group) = (parent = group.find { |other| other.pid == row.ppid }) ? depth(parent, group) + 1 : 0
+
+        def running(group)
+          deepest = group.max_by { |row| [depth(row, group), -row.seconds] }
+          { name: "running", value: "#{deepest.command} (#{deepest.seconds}s)" }
+        end
+
+        def tree(group)
+          lines = ordered(group, group.reject { |row| group.any? { |other| other.pid == row.ppid } }, 0)
+          { title: "Processes still running at the kill", location: "ps", lines: lines }
+        end
+
+        def ordered(group, rows, level)
+          rows.sort_by(&:pid).flat_map do |row|
+            ["#{"  " * level}#{row.pid} #{row.seconds}s #{row.command}",
+             *ordered(group, group.select { |child| child.ppid == row.pid }, level + 1)]
+          end
+        end
+      end
+    end
+  end
+end