fun_ci 2.0.0-aarch64-linux

data/lib/fun_ci/evidence/process_table.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module FunCi
+  module Evidence
+    # The processes running on the machine, as `ps` lists them: BSD and
+    # procps take `-A -o pid=,ppid=,pgid=,etime=,args=`; busybox (the musl
+    # target's) takes neither -A nor `=`, and lists every process with a
+    # header under `-o pid,ppid,pgid,etime,args`.
+    module ProcessTable
+      Row = Data.define(:pid, :ppid, :pgid, :seconds, :command)
+      COMMANDS = [%w[ps -A -o pid=,ppid=,pgid=,etime=,args=], %w[ps -o pid,ppid,pgid,etime,args]].freeze
+      LINE = /\A\s*(\d+)\s+(\d+)\s+(\d+)\s+(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)\s+(.*)\z/
+
+      # What `ps` lists now, from the first form this machine's ps takes.
+      def self.now
+        COMMANDS.each do |command|
+          listing, status = Open3.capture2e(*command)
+          return parse(listing) if status.success?
+        end
+        []
+      end
+
+      def self.parse(listing) = listing.lines(chomp: true).filter_map { |line| row(line) }
+
+      def self.row(line)
+        match = LINE.match(line)
+        return nil unless match
+
+        Row.new(pid: match[1].to_i, ppid: match[2].to_i, pgid: match[3].to_i, command: match[8],
+                seconds: seconds(match.captures[3, 4].map(&:to_i)))
+      end
+
+      # Elapsed [days, hours, minutes, seconds] in seconds.
+      def self.seconds(parts) = parts.zip([86_400, 3600, 60, 1]).sum { |count, unit| count * unit }
+      private_class_method :row, :seconds
+    end
+  end
+end

data/lib/fun_ci/evidence/saved_run.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module FunCi
+  module Evidence
+    # A failed run's stage directory, stood in for by what `fun-ci extract`
+    # is given: a scratch directory for what a project's command reads and
+    # writes.
+    class SavedRun
+      def initialize(scratch)
+        @scratch = scratch
+      end
+
+      attr_reader :scratch
+
+      def output_file(text)
+        File.join(@scratch, "output.log").tap { |file| File.binwrite(file, text) }
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/section_walk.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # Finds sections line by line: one opens on a start line, and closes
+    # before an end line or once it is `limit` lines long (cut); the line
+    # that closes one may open the next, so back-to-back items each get one.
+    class SectionWalk
+      # first, last: line indexes; cut: whether the limit closed it.
+      Found = Data.define(:first, :last, :cut)
+
+      def initialize(starts, ends, limit)
+        @starts = starts
+        @ends = ends
+        @limit = limit
+        @found = []
+      end
+
+      def step(line, index)
+        carry_on(line, index) if open?
+        @found << Found.new(first: index, last: nil, cut: false) if !open? && matches?(@starts, line)
+      end
+
+      # The sections found, the one still open ending at the last line, each
+      # without the blank lines it ends with.
+      def finish(lines)
+        close(lines.size - 1, cut: false) if open?
+        @found.map { |found| found.with(last: last_written(lines, found)) }
+      end
+
+      private
+
+      def carry_on(line, index)
+        return close(index - 1, cut: false) if matches?(@ends, line)
+
+        close(index - 1, cut: true) if index - @found.last.first >= @limit
+      end
+
+      def matches?(patterns, line) = patterns.any? { |pattern| pattern.match?(line) }
+
+      def last_written(lines, found)
+        found.last.downto(found.first).find { |index| !lines[index].strip.empty? } || found.first
+      end
+
+      def open? = !@found.empty? && @found.last.last.nil?
+      def close(last, cut:) = @found[-1] = @found.last.with(last: last, cut: cut)
+    end
+  end
+end

data/lib/fun_ci/evidence/settings.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "catalog"
+require_relative "patterns"
+require_relative "settings_check"
+
+module FunCi
+  module Evidence
+    # The `evidence` key of .fun-ci/config (architecture.md, "Evidence of a failed stage"): the
+    # settings, each with its default, and each stage's entries, those for
+    # `all` first. A setting that is wrong takes its default; #errors says
+    # what is wrong, for `fun-ci check`.
+    class Settings
+      DEFAULTS = { "budget" => 2, "detect" => true, "skip" => [], "mask" => [], "masking" => true,
+                   "stages" => {} }.freeze
+
+      # The settings in the config file at `path`, or the defaults without one.
+      def self.load(path)
+        new(File.exist?(path) ? (YAML.safe_load_file(path) || {})["evidence"] : nil)
+      rescue Psych::Exception, NoMethodError, TypeError
+        new(nil)
+      end
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def budget = SettingsCheck.seconds(value("budget")) || DEFAULTS.fetch("budget").to_f
+      def detect? = value("detect") != false
+      def masking? = value("masking") != false
+      def skip = Array(value("skip"))
+
+      def mask_patterns
+        Array(value("mask")).select { |source| source.is_a?(String) && !Patterns.mistake(source) }
+                            .then { |sources| Patterns.compile(sources) }
+      end
+
+      # The raw entries for `stage`: those for every stage, then its own.
+      def entries(stage) = stage_list("all") + stage_list(stage)
+
+      # The globs whose files are stamped when the stage starts, so what it
+      # wrote to them can be told from what was there before.
+      def watched(stage)
+        entries(stage).grep(Hash).flat_map { |raw| Array(raw["path"]) + Array(raw["paths"]) + Array(raw["watch"]) }
+                      .grep(String).uniq
+      end
+
+      # root: the project, whose `run:` scripts are checked when it is given.
+      def errors(root: nil) = SettingsCheck.new(@raw, root).errors
+
+      private
+
+      def values = @raw.is_a?(Hash) ? DEFAULTS.merge(@raw) : DEFAULTS
+      def value(key) = values[key]
+
+      def stage_list(stage)
+        stages = value("stages")
+        list = stages[stage] if stages.is_a?(Hash)
+        list.is_a?(Array) ? list : []
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/settings_check.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "catalog"
+require_relative "patterns"
+
+module FunCi
+  module Evidence
+    # What is wrong with the `evidence` key of .fun-ci/config, each as a line
+    # `fun-ci check` prints.
+    class SettingsCheck
+      KNOWN = %w[budget detect skip mask masking stages].freeze
+      STAGES = %w[all lint build fast slow].freeze
+
+      # "2", 2, 2.5 or "2s" as seconds, or nil.
+      def self.seconds(value)
+        return value.to_f if value.is_a?(Numeric) && value.positive?
+
+        match = /\A(\d+(?:\.\d+)?)s?\z/.match(value.to_s)
+        match && match[1].to_f.positive? ? match[1].to_f : nil
+      end
+
+      def initialize(raw, root)
+        @raw = raw
+        @root = root
+      end
+
+      def errors
+        return [] if @raw.nil?
+        return ["evidence must be a mapping, not #{@raw.inspect}"] unless @raw.is_a?(Hash)
+
+        unknown + budget + stages
+      end
+
+      private
+
+      def unknown = (@raw.keys - KNOWN).map { |key| "evidence has no setting '#{key}'" }
+
+      def budget
+        return [] if !@raw.key?("budget") || self.class.seconds(@raw["budget"])
+
+        ["evidence.budget must be a number of seconds such as 2 or 2s, not #{@raw["budget"].inspect}"]
+      end
+
+      def stages
+        lists = @raw.fetch("stages", {})
+        return ["evidence.stages must be a mapping of stage to entries"] unless lists.is_a?(Hash)
+
+        lists.flat_map { |stage, entries| stage_errors(stage, entries) }
+      end
+
+      def stage_errors(stage, entries)
+        unless STAGES.include?(stage)
+          return ["evidence.stages has no stage '#{stage}': use all, lint, build, fast or slow"]
+        end
+
+        Array(entries).filter_map { |entry| refusal(entry) }.map { |message| "evidence.stages.#{stage}: #{message}" }
+      end
+
+      def refusal(entry)
+        Catalog.entry(entry)
+        script_mistake(entry)
+      rescue Catalog::Refused => e
+        e.message
+      end
+
+      # A `run:` command's first word, when it is a path, must name a script that can be run.
+      def script_mistake(entry)
+        script = entry["run"].to_s.split.first.to_s
+        return nil unless @root && script.include?("/")
+
+        path = File.join(@root, script)
+        return "run:#{entry["run"]}: #{script} doesn't exist" unless File.exist?(path)
+
+        "run:#{entry["run"]}: #{script} isn't executable" unless File.executable?(path)
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/source.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # The lines an extractor reads, and the name of where they came from: the
+    # output, or a file in the worktree. Colour codes are stripped and bytes
+    # that aren't UTF-8 replaced, so patterns match what a person would read.
+    # `skipped` is how many lines of the file came before these.
+    Source = Data.define(:name, :lines, :skipped)
+
+    class Source
+      COLOUR = /\e\[[0-9;?]*[A-Za-z]/
+
+      def self.for(context, path)
+        return of("output", context.output) unless path
+
+        of(path, context.worktree.read(path))
+      end
+
+      def self.of(name, text, skipped: 0)
+        lines = text.dup.force_encoding(Encoding::UTF_8).scrub("?").gsub(COLOUR, "").lines(chomp: true)
+        new(name: name, lines: lines, skipped: skipped)
+      end
+
+      # Where lines first..last (counted from 0) are, as `name:first-last`
+      # counted from 1 in the whole file.
+      def location(first, last)
+        from = first + skipped + 1
+        to = last + skipped + 1
+        from == to ? "#{name}:#{from}" : "#{name}:#{from}-#{to}"
+      end
+    end
+  end
+end

data/lib/fun_ci/evidence/sources.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # Where a failed stage's evidence can come from while it still holds its
+    # slot (architecture.md, "Evidence of a failed stage"): the stage, the worktree
+    # it ran in, its stage directory, its environment as a hash,
+    # the Stamp of each watched file when it started, by path, its budget,
+    # its commit ({ sha:, branch: }), when it started, `processes`, which
+    # answers what ps lists, for a stage that runs over budget, and the
+    # presets that were candidates when it started (Detection::Found).
+    Sources = Data.define(:stage, :worktree, :stage_dir, :environment, :watched, :budget, :commit, :started, :processes,
+                          :candidates)
+
+    class Sources
+      UNKNOWN = { watched: {}, budget: nil, commit: nil, started: nil, processes: -> { [] }, candidates: [] }.freeze
+
+      def initialize(**given) = super(**UNKNOWN, **given)
+    end
+  end
+end

data/lib/fun_ci/evidence/stage_context.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "context"
+require_relative "deadline"
+require_relative "worktree"
+require_relative "about_stage"
+
+module FunCi
+  module Evidence
+    # Makes the Context a stage's extractors are given, with a deadline
+    # `seconds` from now.
+    class StageContext
+      def initialize(sources, clock, commands)
+        @sources = sources
+        @clock = clock
+        @commands = commands
+      end
+
+      def after(output, outcome, seconds)
+        Context.new(stage: @sources.stage, output: output, worktree: Worktree.new(@sources.worktree),
+                    deadline: Deadline.after(@clock, seconds), watched: @sources.watched,
+                    about: AboutStage.of(@sources, outcome, output), commands: @commands,
+                    processes: @sources.processes)
+      end
+
+      # Before the kill of a stage over budget, while its group still runs.
+      def before_kill(pgid, seconds) = after("", Outcome.new(state: "over_budget"), seconds).with(pgid: pgid)
+    end
+  end
+end

data/lib/fun_ci/evidence/stamp.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Evidence
+    # What a watched file looked like: a file counts as changed if any of
+    # the three differ, since some file systems keep whole seconds, and
+    # `cp -p` or a build cache can put an old time back (architecture.md, "Evidence of a failed stage").
+    Stamp = Data.define(:size, :mtime, :inode)
+  end
+end

data/lib/fun_ci/evidence/start.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "collector"
+require_relative "settings"
+require_relative "worktree"
+require_relative "detection"
+
+module FunCi
+  module Evidence
+    # What happens when a stage starts, so its evidence can be collected if
+    # it fails: its settings are read from the worktree, so they are the
+    # commit's own, and the files it watches are stamped.
+    module Start
+      def self.collector(sources, clock, commands)
+        settings = Settings.load(File.join(sources.worktree, ".fun-ci", "config"))
+        worktree = Worktree.new(sources.worktree)
+        Collector.new(sources.with(watched: stamps(worktree, settings.watched(sources.stage)),
+                                   candidates: candidates(worktree, settings, sources.stage)),
+                      settings: settings, clock: clock, commands: commands)
+      end
+
+      # The presets that may run: detected ones, less those skipped or configured.
+      def self.candidates(worktree, settings, stage)
+        return [] unless settings.detect?
+
+        left_out = settings.skip + settings.entries(stage).grep(Hash).filter_map { |raw| raw["preset"] }
+        Detection.candidates(worktree, Presets.all.reject { |preset| left_out.include?(preset.name) })
+      end
+
+      def self.stamps(worktree, globs)
+        globs.flat_map { |glob| worktree.glob(glob) }.uniq.to_h { |path| [path, worktree.stamp(path)] }
+      end
+      private_class_method :stamps
+    end
+  end
+end

data/lib/fun_ci/evidence/worktree.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "stamp"
+require_relative "../pipeline/output_window"
+
+module FunCi
+  module Evidence
+    # The files of the worktree a stage ran in, by path relative to it. A
+    # file is read through a window of the output's sizes, so a log that
+    # grew without end is read as its first and last parts.
+    class Worktree
+      CHUNK = 1_048_576
+
+      def initialize(dir, sizes = Pipeline::OutputWindow::REAL)
+        @dir = dir
+        @sizes = sizes
+      end
+
+      def exist?(path) = File.file?(full(path))
+      def glob(pattern) = Dir.glob(pattern, base: @dir).select { |path| exist?(path) }.sort
+
+      def read(path, from: 0)
+        window = Pipeline::OutputWindow.in_memory(@sizes)
+        each_chunk(path, from) { |chunk| window << chunk }
+        window.text
+      end
+
+      def lines_before(path, offset)
+        count = 0
+        each_chunk(path, 0, offset) { |chunk| count += chunk.count("\n") }
+        count
+      end
+
+      def stamp(path)
+        stat = File.stat(full(path))
+        Stamp.new(size: stat.size, mtime: stat.mtime.to_r, inode: stat.ino)
+      end
+
+      private
+
+      def full(path) = File.join(@dir, path)
+
+      # Yields the file's bytes from `from`, `length` of them or to its end, a chunk at a time.
+      def each_chunk(path, from, length = nil, &)
+        File.open(full(path), "rb") do |file|
+          file.seek(from)
+          read_chunks(file, length, &)
+        end
+      end
+
+      def read_chunks(file, left)
+        loop do
+          chunk = file.read(left ? [CHUNK, left].min : CHUNK)
+          break if chunk.nil? || chunk.empty?
+
+          yield chunk
+          left -= chunk.bytesize if left
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/persistence/active_runs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "pipeline_run"
+require_relative "stage_job"
+
+module FunCi
+  module Persistence
+    # A run that has not finished: the processes running it (the trigger and
+    # the forked slow suite), the process group of each stage still going, and
+    # the lock of the worktree slot it holds (nil while it waits for one).
+    ActiveRun = Data.define(:id, :commit_hash, :processes, :stage_groups, :slot_lock)
+
+    # A branch of one project. Every project records its runs in the same
+    # database, and two projects can each have a main.
+    Branch = Data.define(:project, :name)
+
+    # Runs waiting for a slot or running, and recording one as cancelled.
+    module ActiveRuns
+      ACTIVE = "status IN ('scheduled', 'running')"
+
+      # The runs on the branch a new commit's run may cancel: not the new
+      # commit's own, nor one an agent has waited on since `waited_before`
+      # (an ISO 8601 UTC time; acceptance-tests.md, AT-9.12).
+      def self.cancellable(db, branch, new_commit:, waited_before:)
+        where(db, "project_path = ? AND branch = ? AND commit_hash != ? AND (waited_at IS NULL OR waited_at < ?)",
+              branch.project, branch.name, new_commit, waited_before)
+      end
+
+      # The run with this id, when it has not finished; none otherwise.
+      def self.with_id(db, id) = where(db, "id = ?", id)
+
+      # [job id, run id, pid] for each slow stage still running, pid being the
+      # forked process that runs it.
+      def self.slow_suites(db)
+        db.execute("SELECT stage_jobs.id, pipeline_runs.id, pipeline_runs.pid FROM stage_jobs " \
+                   "JOIN pipeline_runs ON pipeline_runs.id = stage_jobs.pipeline_run_id " \
+                   "WHERE stage_jobs.stage = 'slow' AND stage_jobs.status = 'running' " \
+                   "AND pipeline_runs.pid IS NOT NULL")
+      end
+
+      # Records the slow stage failed, unless its result was recorded meanwhile.
+      def self.slow_suite_died(db, job_id)
+        db.execute("UPDATE stage_jobs SET status = 'failed', completed_at = ? WHERE id = ? AND status = 'running'",
+                   [Time.now.utc.iso8601, job_id])
+      end
+
+      def self.cancelled(db, run)
+        db.execute("UPDATE stage_jobs SET status = 'cancelled', completed_at = ? " \
+                   "WHERE pipeline_run_id = ? AND #{ACTIVE}", [Time.now.utc.iso8601, run.id])
+        PipelineRun.update_status(db, run.id, "cancelled")
+      end
+
+      def self.where(db, clause, *values)
+        db.execute("SELECT id, commit_hash, trigger_pid, pid, slot_lock FROM pipeline_runs " \
+                   "WHERE #{clause} AND #{ACTIVE} ORDER BY id", values).map { |row| active_run(db, row) }
+      end
+      private_class_method :where
+
+      def self.active_run(db, (id, commit_hash, trigger_pid, pid, slot_lock))
+        groups = db.execute("SELECT pid FROM stage_jobs WHERE pipeline_run_id = ? AND #{ACTIVE} AND pid IS NOT NULL",
+                            [id]).flatten
+        ActiveRun.new(id: id, commit_hash: commit_hash, processes: [trigger_pid, pid].compact, stage_groups: groups,
+                      slot_lock: slot_lock)
+      end
+      private_class_method :active_run
+    end
+  end
+end

data/lib/fun_ci/persistence/database.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+
+module FunCi
+  module Persistence
+    module Database
+      PIPELINE_RUNS_TABLE = <<~SQL
+        CREATE TABLE IF NOT EXISTS pipeline_runs (
+          id INTEGER PRIMARY KEY,
+          commit_hash TEXT,
+          branch TEXT,
+          status TEXT DEFAULT 'scheduled',
+          pid INTEGER,
+          created_at TEXT,
+          updated_at TEXT
+        )
+      SQL
+
+      STAGE_JOBS_TABLE = <<~SQL
+        CREATE TABLE IF NOT EXISTS stage_jobs (
+          id INTEGER PRIMARY KEY,
+          pipeline_run_id INTEGER REFERENCES pipeline_runs(id),
+          stage TEXT,
+          status TEXT DEFAULT 'scheduled',
+          started_at TEXT,
+          completed_at TEXT
+        )
+      SQL
+
+      # Opening and migrating hold an exclusive lock on a file beside the
+      # database, so fun-ci processes starting at once set it up one at a time.
+      # SQLite's busy timeout doesn't cover the switch to WAL, and a column can
+      # appear between one process's check and its ALTER.
+      def self.connection(db_path, open: SQLite3::Database.method(:new))
+        with_setup_lock(db_path) { configure(open.call(db_path)) }
+      end
+
+      # Columns added after the tables were first released, so older
+      # databases gain them on the next migrate!.
+      ADDED_COLUMNS = [%w[pipeline_runs pid INTEGER], %w[pipeline_runs project_path TEXT],
+                       %w[pipeline_runs trigger_pid INTEGER], %w[pipeline_runs slot_lock TEXT],
+                       %w[stage_jobs pid INTEGER], %w[stage_jobs finished_order INTEGER],
+                       %w[stage_jobs output_tail TEXT], %w[stage_jobs failures TEXT],
+                       %w[pipeline_runs waited_at TEXT], %w[stage_jobs exit_status INTEGER],
+                       %w[stage_jobs signal TEXT], %w[stage_jobs budget INTEGER], %w[stage_jobs pruned INTEGER],
+                       %w[stage_jobs evidence TEXT]].freeze
+
+      def self.migrate!(db)
+        with_setup_lock(db.filename("main")) do
+          [PIPELINE_RUNS_TABLE, STAGE_JOBS_TABLE].each { |table| db.execute(table) }
+          ADDED_COLUMNS.each { |table, column, type| add_column_if_missing(db, table, column, type) }
+        end
+      end
+
+      def self.with_setup_lock(db_path)
+        File.open("#{db_path}.setup-lock", File::RDWR | File::CREAT, 0o644) do |lock|
+          lock.flock(File::LOCK_EX)
+          yield
+        end
+      end
+      private_class_method :with_setup_lock
+
+      def self.configure(db)
+        db.busy_timeout = 5000
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA foreign_keys=ON")
+        db
+      end
+      private_class_method :configure
+
+      def self.add_column_if_missing(db, table, column, type)
+        columns = db.execute("PRAGMA table_info(#{table})").map { |row| row[1] }
+        return if columns.include?(column)
+
+        db.execute("ALTER TABLE #{table} ADD COLUMN #{column} #{type}")
+      end
+      private_class_method :add_column_if_missing
+    end
+  end
+end

data/lib/fun_ci/persistence/null_recorder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Persistence
+    # Records nothing, for a pipeline run with no database.
+    class NullRecorder
+      def create_run(**); end
+      def start_stage(_stage, **); end
+      def end_stage(_job_id, _status); end
+      def keep_exit(_job_id, _exit_status, _signal); end
+      def keep_evidence(_job_id, _document); end
+      def keep_raw(_job_id, _text); end
+      def alongside(_job_id) = []
+      def stage_process(_job_id, _pid); end
+      def slot_taken(_lock_file); end
+      def foreground_done; end
+      def db; end
+      def db_path; end
+      def pipeline_run_id; end
+      def close; end
+      def tolerating = yield
+      def report_trouble_to(_out); end
+    end
+  end
+end

data/lib/fun_ci/persistence/output_tail.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Persistence
+    # The end of what a stage printed, as fun-ci keeps it for a stage that
+    # failed (acceptance-tests.md, AT-9.5): the last 200 lines, at most 64 KB,
+    # colour codes stripped and bytes that aren't UTF-8 replaced. `mask`
+    # sees the last lines before they are cut to size, so no cut splits a
+    # secret it would have masked.
+    module OutputTail
+      LINES = 200
+      BYTES = 65_536
+      COLOUR = /\e\[[0-9;?]*[A-Za-z]/
+
+      def self.of(output, mask: :itself.to_proc)
+        text = output.dup.force_encoding(Encoding::UTF_8).scrub("?").gsub(COLOUR, "")
+        last_bytes(mask.call(text.lines.last(LINES).join))
+      end
+
+      def self.last_bytes(text) = text.byteslice([text.bytesize - BYTES, 0].max..).scrub("")
+      private_class_method :last_bytes
+    end
+  end
+end