hayaoki 0.1.0

data/lib/hayaoki/boot_report/formatters/json.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../version"
+require_relative "../advisor"
+
+module Hayaoki
+  module BootReport
+    module Formatters
+      class Json
+        SCHEMA_VERSION = 1
+
+        def initialize(pretty: true)
+          @pretty = pretty
+        end
+
+        attr_accessor :suggestions, :suggestion_warnings
+
+        def with_suggestions(list, warnings = [])
+          @suggestions = list
+          @suggestion_warnings = warnings
+          self
+        end
+
+        # reports: { "warm" => Report, ... } または Report 単体
+        def format(reports)
+          reports = { reports.condition.to_s => reports } unless reports.is_a?(Hash)
+          reports = reports.transform_values { |r| scrub(r.to_h) }
+          reports = reports.transform_values { |r| scrub(r.to_h) }
+          doc = { "schema_version" => SCHEMA_VERSION, "hayaoki_version" => Hayaoki::VERSION,
+                  "reports" => reports }
+          if @suggestions
+            doc["suggestions"] = @suggestions.map { |s| s.respond_to?(:to_h) ? s.to_h : s }
+            # 非加算の上限 (findings は重複しうる)
+            doc["savings_upper_bound_ms"] = Suggestion.savings_upper_bound(@suggestions)
+            doc["suggestion_warnings"] = Array(@suggestion_warnings)
+          end
+          (@pretty ? ::JSON.pretty_generate(doc) : ::JSON.generate(doc)) + "\n"
+        end
+
+        private
+
+        # 失敗 run の stderr_tail は秘密を含みうるので出力しない (message / exit_status / error_class は残す)
+        def scrub(h)
+          meta = h["meta"]
+          return h unless meta.is_a?(Hash) && meta["failed_runs"].is_a?(Array)
+          h.merge("meta" => meta.merge("failed_runs" => meta["failed_runs"].map { |f| f.reject { |k, _| k == "stderr_tail" } }))
+        end
+      end
+    end
+  end
+end

data/lib/hayaoki/boot_report/formatters/redact.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hayaoki
+  module BootReport
+    module Formatters
+      # 出力 (JSON / speedscope の文字列) から個人を特定できる絶対パスを消す。
+      # gem のパスは <gem:name>/、アプリのルートは <app>、ホームは ~ に置き換える。
+      class Redact
+        GEM_PATH = %r{(?:/[^\s"/\\]+)+/gems/([^\s"/\\]+?)-(?:\d|[0-9a-f]{7,})[^\s"/\\]*/}
+
+        def initialize(app_dir: nil, home: Dir.home)
+          @apps = []
+          if app_dir
+            exp = File.expand_path(app_dir)
+            real = (File.realpath(exp) rescue exp) # macOS: /var と /private/var
+            @apps = [exp, real].uniq.sort_by { |a| -a.size }
+          end
+          @home = home
+        end
+
+        def apply(text)
+          out = text.gsub(GEM_PATH) { "<gem:#{Regexp.last_match(1)}>/" }
+          @apps.each do |a|
+            out = out.gsub(/#{Regexp.escape(a)}(?=[\/"\s\\]|\z)/, "<app>") unless a == "/"
+          end
+          out = out.gsub(/#{Regexp.escape(@home)}(?=[\/"\s\\]|\z)/, "~") if @home && @home != "/"
+          out
+        end
+      end
+    end
+  end
+end

data/lib/hayaoki/boot_report/formatters/speedscope.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../version"
+
+module Hayaoki
+  module BootReport
+    module Formatters
+      # payload (probe の出力) 1 回分を speedscope の evented 形式にする。メインスレッド (tid 0) のみ。
+      class Speedscope
+        SCHEMA = "https://www.speedscope.app/file-format-schema.json"
+        KINDS = %w[require require_relative load initializer on_load hooks eager_load phase].freeze
+
+        # payloads: 配列。boot の total に一番近い (=中央値に近い) run を選ぶ。
+        def self.pick_median(payloads)
+          ok = payloads.select { |p| p["status"] == "ok" }
+          ok = payloads if ok.empty?
+          sorted = ok.sort_by { |p| p["boot_end_us"] || p["exit_us"] || 0 }
+          sorted[sorted.size / 2]
+        end
+
+        def initialize(name: "hayaoki boot")
+          @name = name
+        end
+
+        # RunResult の payloads (Hash) / 配列 / 単一 payload を受け付ける。
+        def format(input, condition: nil)
+          picks = pick_all(input, condition)
+          docs = picks.map { |name, payload| build(payload, name: name) }
+          doc = docs.first
+          if docs.size > 1
+            # 条件ごとに profile を持つ 1 ファイルにまとめる (frame は条件ごとの添字がずれるので付け替える)
+            frames = []
+            profiles = docs.each_with_index.map do |d, di|
+              map = d["shared"]["frames"].map { |f| frames << f; frames.size - 1 }
+              prof = d["profiles"].first.dup
+              prof["events"] = prof["events"].map { |e| e.merge("frame" => map[e["frame"]]) }
+              prof
+            end
+            doc = doc.merge("shared" => { "frames" => frames }, "profiles" => profiles)
+          end
+          ::JSON.generate(doc) + "\n"
+        end
+
+        def build(payload, name: @name)
+          w = payload["width"] || 8
+          ev = payload["events"] || []
+          exit_us = payload["exit_us"] || ev.each_slice(w).filter_map { |e| e[4] }.max || 0
+          spans = ev.each_slice(w).with_index.map do |(kind, n, par, t0, t1, _res, tid), i|
+            { idx: i * w, kind: kind, name: n, parent: par, t0: t0, t1: t1 || [exit_us, t0].max, tid: tid.to_i, kids: [] }
+          end
+          main = spans.select { |s| s[:tid].zero? }
+          by = main.to_h { |s| [s[:idx], s] }
+          roots = []
+          main.each { |s| (by[s[:parent]] ? by[s[:parent]][:kids] : roots) << s }
+          origin = main.map { |s| s[:t0] }.min || 0
+          frames = []
+          fidx = {}
+          events = []
+          emit = lambda do |s, lo, hi|
+            a = [[s[:t0], lo].max, hi].min
+            b = [[s[:t1], a].max, hi].min
+            key = [s[:kind], s[:name]]
+            f = (fidx[key] ||= (frames << { "name" => "#{KINDS[s[:kind]] || s[:kind]}: #{s[:name]}" }; frames.size - 1))
+            events << { "type" => "O", "frame" => f, "at" => a - origin }
+            cursor = a
+            s[:kids].sort_by { |k| k[:t0] }.each do |k|
+              next if k[:t0] < cursor && k[:t1] <= cursor
+              emit.call(k, cursor, b)
+              cursor = [cursor, [k[:t1], b].min].max
+            end
+            events << { "type" => "C", "frame" => f, "at" => b - origin }
+          end
+          cursor = origin
+          roots.sort_by { |s| s[:t0] }.each do |s|
+            next if s[:t1] <= cursor && s[:t0] < cursor
+            emit.call(s, cursor, [s[:t1], cursor].max)
+            cursor = [cursor, s[:t1]].max
+          end
+          end_value = [events.map { |e| e["at"] }.max || 0, 0].max
+          {
+            "$schema" => SCHEMA,
+            "shared" => { "frames" => frames },
+            "profiles" => [{ "type" => "evented", "name" => name, "unit" => "microseconds",
+                             "startValue" => 0, "endValue" => end_value, "events" => events }],
+            "name" => @name, "activeProfileIndex" => 0, "exporter" => "hayaoki #{Hayaoki::VERSION}"
+          }
+        end
+
+        private
+
+        # [[profile 名, payload], ...]。condition 指定が無く複数条件 (bootsnap: both) なら条件ごとに出す。
+        def pick_all(input, condition)
+          if !condition && !input.is_a?(Array) && !(input.is_a?(Hash) && input.key?("events"))
+            map = input.is_a?(Hash) ? input : input.payloads
+            if map.size > 1
+              return map.map { |c, list| ["#{@name} [#{c}]", self.class.pick_median(list)] }
+            end
+          end
+          [[@name, pick(input, condition)]]
+        end
+
+        def pick(input, condition)
+          case input
+          when Hash
+            if input.key?("events") then input
+            else self.class.pick_median(condition ? input[condition.to_s] : input.values.first)
+            end
+          when Array then self.class.pick_median(input)
+          else
+            list = condition ? input.payloads[condition.to_s] : input.payloads.values.first
+            self.class.pick_median(list)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hayaoki/boot_report/formatters/text.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative "../advisor"
+
+module Hayaoki
+  module BootReport
+    module Formatters
+      # 端末向けテキスト。reports は { "warm" => Report, "cold" => Report } (aggregate_result の戻り値)。
+      class Text
+        WIDTH = 80
+        BAR = "█"
+        BAR_WIDTH = 28
+        PHASE_LABELS = { "vm_boot" => "vm boot", "bundler_require" => "bundler require", "initialize" => "initialize",
+                         "eager_load" => "eager load", "boot" => "boot" }.freeze
+
+        # redact: 文字列を受け取って伏せた文字列を返すもの (--redact)。切り詰める前に適用しないとパスが一致しない。
+        def initialize(top: 10, redact: nil)
+          @top = top
+          @redact = redact
+        end
+
+        # Advisor の結果 (Suggestion の配列 / 警告の配列)。nil なら Suggestions の節を出さない。
+        attr_accessor :suggestions, :suggestion_warnings
+
+        def with_suggestions(list, warnings = [])
+          @suggestions = list
+          @suggestion_warnings = warnings
+          self
+        end
+
+        def format(reports)
+          reports = { reports.condition.to_s => reports } unless reports.is_a?(Hash)
+          @conds = reports.keys
+          @reports = reports
+          out = []
+          header(out)
+          phases(out)
+          categories(out)
+          ranked(out, "Top gems (self time)", :gems, ->(r) { r.gems }, ->(e) { e["name"] }, "self_ms", breakdown: { "req" => "require_ms", "onload" => "on_load_ms", "eager" => "eager_ms" })
+          ranked(out, "Top initializers (inclusive)", :inits, ->(r) { r.initializers }, ->(e) { [e["name"], e["context"]].compact.join(" ") }, "inclusive_ms",
+                 breakdown: { "init body (own time, not blamed on gem)" => "init_body_ms" })
+          ranked(out, "Top on_load hooks (inclusive)", :on_loads, ->(r) { r.on_loads }, ->(e) { [e["name"], e["source"]].compact.join(" ") }, "inclusive_ms")
+          if @reports.values.any? { |r| Array(r.eager_namespaces).any? }
+            ranked(out, "Top eager_load namespaces (inclusive)", :eager_namespaces, ->(r) { r.eager_namespaces }, ->(e) { e["name"] }, "inclusive_ms")
+          end
+          false_requires(out)
+          overhead(out)
+          warnings(out)
+          suggestions_section(out)
+          out.map { |l| clip(l) }.join("\n") + "\n"
+        end
+
+        private
+
+        def header(out)
+          m = (@reports.values.first.meta || {})
+          out << "hayaoki boot-report"
+          out << "  app: #{m["app_dir"]}" if m["app_dir"]
+          out << "  runs=#{m["runs"] || @reports.values.first.runs} env=#{m["env"]} bootsnap=#{m["bootsnap"] || @conds.join(",")}"
+          @reports.each do |c, r|
+            failed = r.failed.to_i.positive? ? "  (#{r.failed} failed)" : ""
+            out << "  total[#{c}]: #{stat_s(r.phases["total"])}#{failed}"
+          end
+          out << "  diff (#{@conds.last} - #{@conds.first}): #{diff_s(med(first_total), med(last_total))}" if @conds.size > 1
+          out << ""
+        end
+
+        def first_total = @reports[@conds.first].phases["total"]
+        def last_total = @reports[@conds.last].phases["total"]
+
+        def phases(out)
+          out << "Phases (median)"
+          keys = PHASE_LABELS.keys.select { |k| @reports.values.any? { |r| r.phases[k] } }
+          max = keys.flat_map { |k| @reports.values.map { |r| med(r.phases[k]) } }.compact.max.to_f
+          keys.each do |k|
+            @reports.each do |c, r|
+              s = r.phases[k]
+              next unless s
+              label = @conds.size > 1 ? "#{PHASE_LABELS[k]} [#{c}]" : PHASE_LABELS[k]
+              label = "  └ #{label}" if k == "eager_load" # initialize の内側 (足し算しない)
+              n = max.positive? ? (med(s) / max * BAR_WIDTH).round : 0
+              n = 1 if n.zero? && med(s).to_f.positive?
+              out << Kernel.format("  %-22s %-#{BAR_WIDTH}s %s", label, BAR * n, stat_s(s, range: @conds.size == 1))
+            end
+          end
+          out << "  (└ eager load runs within initialize; do not add them)" if keys.include?("eager_load")
+          out << ""
+        end
+
+        def categories(out)
+          return if @reports.values.all? { |r| (r.categories || {}).empty? }
+          out << "Self time by category (median; boot - attributed = unattributed)"
+          @reports.each do |c, r|
+            cats = r.categories || {}
+            next if cats.empty?
+            tag = @conds.size > 1 ? " [#{c}]" : ""
+            cats.each { |k, v| out << Kernel.format("  %-22s %10s", "#{k}#{tag}", "#{fmt(med(v["self_ms"]))}") }
+          end
+          out << ""
+        end
+
+        def ranked(out, title, _key, getter, namer, metric, breakdown: nil)
+          out << "#{title} (top #{@top})"
+          lists = @reports.transform_values { |r| Array(getter.call(r)) }
+          names = lists.values.first.first(@top).map(&namer)
+          if @conds.size > 1
+            names |= lists.values.last.first(@top).map(&namer)
+            names = names.first(@top * 2)
+          end
+          if names.empty?
+            out << "  (none)"
+            out << ""
+            return
+          end
+          idx = lists.transform_values { |l| l.to_h { |e| [namer.call(e), e] } }
+          nw = [WIDTH - 2 - 12 * @conds.size - (@conds.size > 1 ? 10 : 22), 20].max
+          names.each do |n|
+            vals = @conds.map { |c| idx[c][n] && idx[c][n][metric] }
+            line = Kernel.format("  %-#{nw}s", trunc(n.to_s, nw))
+            vals.each { |v| line += Kernel.format(" %10s", v ? "#{fmt(med(v))}" : "-") }
+            if @conds.size > 1
+              line += Kernel.format(" %9s", vals.all? ? signed(med(vals.last) - med(vals.first)) : "-")
+            else
+              v = vals.first
+              line += Kernel.format(" %-20s", v ? "[#{fmt(v["min"])}-#{fmt(v["max"])}]" : "")
+              e = idx[@conds.first][n]
+              if breakdown && e
+                out << line.rstrip
+                parts = breakdown.filter_map do |l, kk|
+                  x = e[kk] && med(e[kk])
+                  "#{l} #{fmt(x)}" if x && x >= 0.05
+                end
+                next if parts.empty?
+                cat = e["category"] ? "#{e["category"]}: " : ""
+                out << "      #{cat}#{parts.join(", ")}".rstrip
+                next
+              end
+            end
+            out << line.rstrip
+          end
+          out << "  (ms, median)" if @conds.size > 1
+          out << ""
+        end
+
+        def false_requires(out)
+          out << "require that returned false"
+          @reports.each do |c, r|
+            f = r.false_require || {}
+            tag = @conds.size > 1 ? " [#{c}]" : ""
+            out << "  count#{tag}: #{f["count"] ? fmt(med(f["count"]), 0) : "-"}, time: #{stat_s(f["time_ms"])}"
+          end
+          out << ""
+        end
+
+        def overhead(out)
+          out << "Measurement overhead"
+          ov = (@reports.values.first.meta || {})["overhead"] || {}
+          @conds.each do |c|
+            o = ov[c]
+            next out << "  #{c}: n/a" unless o
+            ratio = o["ratio"] ? Kernel.format(", x%.3f", o["ratio"]) : ""
+            noise = overhead_noise(o)
+            diff = if noise && o["diff_ms"].abs < noise
+                     "diff within noise (±#{fmt(noise)} ms) (#{signed(o["diff_ms"])} ms#{ratio})"
+                   else
+                     "diff #{signed(o["diff_ms"])} ms#{ratio.empty? ? "" : " (#{ratio[2..]})"}"
+                   end
+            out << "  #{c}: baseline #{fmt(o["baseline_ms"])} ms, with probe #{fmt(o["probe_ms"])} ms"
+            out << "    #{diff}"
+          end
+          out << ""
+        end
+
+        # 基準側と probe 側の run ごとのばらつき (min〜max の半幅) の大きい方。サンプルが 2 件未満なら nil。
+        def overhead_noise(o)
+          halves = %w[baseline_samples_ms probe_samples_ms].filter_map do |k|
+            v = Array(o[k]).compact
+            (v.max - v.min) / 2.0 if v.size >= 2
+          end
+          halves.max
+        end
+
+        def warnings(out)
+          w = @reports.values.flat_map { |r| Array(r.warnings) }.uniq
+          return if w.empty?
+          out << "Warnings"
+          w.each { |x| out << "  ! #{x}" }
+        end
+
+        SUGGESTION_ORDER = %w[high medium low info].freeze
+
+        def suggestions_section(out)
+          return unless @suggestions
+          out << ""
+          out << "Suggestions"
+          if @suggestions.empty?
+            out << "  (none)"
+          end
+          sorted = @suggestions.each_with_index.sort_by { |s, i| [SUGGESTION_ORDER.index(s.confidence.to_s) || 9, i] }.map(&:first)
+          sorted.each do |s|
+            wrap("[#{s.confidence}] #{s.title}", 2, 9).each { |l| out << l }
+            wrap("id: #{s.id}", 9, 11).each { |l| out << l } if s.id
+            ev = Array(s.evidence)
+            ev.first(5).each { |e| wrap("- #{evidence_s(e)}", 9, 11).each { |l| out << l } }
+            out << "         - (+#{ev.size - 5} more)" if ev.size > 5
+            out << "         estimated savings: up to #{fmt(s.estimated_savings_ms)} ms" if s.estimated_savings_ms
+            wrap("overlaps with: #{s.overlaps.join(", ")} (savings not additive)", 9, 11).each { |l| out << l } unless Array(s.overlaps).empty?
+            out << "         action:"
+            s.action.to_s.split("\n").each do |line|
+              lead = line[/\A */].size
+              wrap(line.strip, 11 + lead, 13 + lead).each { |l| out << l }
+            end
+          end
+          ub = Suggestion.savings_upper_bound(@suggestions)
+          if ub && @suggestions.count(&:estimated_savings_ms) > 1
+            wrap("total savings: at most #{fmt(ub)} ms (upper bound; findings overlap, so do not treat as additive)", 2, 4).each { |l| out << l }
+          end
+          Array(@suggestion_warnings).each { |w| wrap("! #{w}", 2, 4).each { |l| out << l } }
+        end
+
+        def evidence_s(e)
+          e.is_a?(Hash) ? e.map { |k, v| "#{k}=#{v.is_a?(Array) ? v.join("/") : v}" }.join(" ") : e.to_s
+        end
+
+        # 80 桁に収まるように単語で折り返す。1 行目は indent、続きは cont 桁で字下げする。
+        def wrap(text, indent, cont)
+          lines = []
+          cur = " " * indent
+          fresh = true
+          text.to_s.split(/\s+/).reject(&:empty?).each do |w|
+            w = w[0, WIDTH - cont - 2] + "…" if w.length > WIDTH - cont - 1
+            if !fresh && cur.length + 1 + w.length > WIDTH - 1
+              lines << cur
+              cur = " " * cont
+              fresh = true
+            end
+            cur += (fresh ? "" : " ") + w
+            fresh = false
+          end
+          lines << cur
+        end
+
+        def med(s) = s.is_a?(Hash) ? s["median"] : s
+
+        def fmt(x, digits = 1)
+          x.nil? ? "-" : Kernel.format("%.#{digits}f", x)
+        end
+
+        def signed(x) = Kernel.format("%+.1f", x)
+
+        def diff_s(a, b)
+          return "-" unless a && b
+          pct = a.positive? ? Kernel.format(" (%+.1f%%)", (b - a) / a * 100) : ""
+          "#{signed(b - a)} ms#{pct}"
+        end
+
+        def stat_s(s, range: true)
+          return "-" unless s
+          base = "#{fmt(s["median"])} ms"
+          range ? "#{base} [#{fmt(s["min"])}-#{fmt(s["max"])}]" : base
+        end
+
+        def trunc(s, w)
+          s = @redact.call(s) if @redact
+          s.length > w ? "…#{s[-(w - 1)..]}" : s
+        end
+
+        def clip(l)
+          l = @redact.call(l) if @redact
+          l.length > WIDTH ? l[0, WIDTH - 1] + "…" : l
+        end
+      end
+    end
+  end
+end

data/lib/hayaoki/boot_report/gemfile.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Hayaoki
+  module BootReport
+    # Gemfile の行ベースの簡易パーサ (eval しない)。
+    # group ブロック / インラインの group: groups: / require: / eval_gemfile を拾う。
+    module Gemfile
+      # groups: 空配列 = どの group にも属さない (production で読み込まれる)
+      # require: nil (指定なし) / false / 文字列の配列 (別名で require される)
+      Entry = Struct.new(:name, :groups, :require, keyword_init: true)
+
+      GEM_RE = /\A\s*gem\s*\(?\s*["']([^"']+)["']/
+      GROUP_BLOCK_RE = /\A\s*group\s*\(?\s*([^#]*?)\)?\s+do\b/
+      GROUP_ONELINE_RE = /\A\s*group\s*\(?\s*([^#]*?)\)?\s+do\b(.*)\bend\s*\z/
+      DO_BLOCK_RE = /\bdo\s*(\|[^|]*\|)?\s*\z/
+      END_RE = /\A\s*end\b/
+      # 文のかたち (modifier の `gem "x" if foo` は行頭が gem なのでここには来ない)
+      STATEMENT_RE = /\A\s*(?:if|unless|case|while|until|begin|def|class|module|for)\b/
+      EVAL_RE = /\beval_gemfile\s*\(?\s*(?:["']([^"']+)["']|\w+)/
+      GLOB_RE = /Dir(?:\.glob\s*\(?|\s*\[)\s*(?:[\w.:]*expand_path\s*\(\s*)?["']([^"']+)["']/
+      PERCENT_RE = /%[iIwW][\[(]([^\])]*)[\])]/
+      MAX_DEPTH = 8
+
+      module_function
+
+      # dir: eval_gemfile の相対パスの基準 (Gemfile のあるディレクトリ)。nil なら eval_gemfile は無視する。
+      # => { "gem-name" => Entry }
+      def parse(src, dir: nil)
+        entries = {}
+        walk(src, dir, entries, [], Set.new, 0)
+        entries
+      end
+
+      def walk(src, dir, entries, base_groups, seen, depth)
+        stack = [base_groups] # 各要素: group 名の配列 (group ブロック) か nil (その他のブロック)
+        glob = nil
+        logical_lines(src).each do |line|
+          if (m = line.match(GROUP_ONELINE_RE))
+            add_gem(entries, m[2], stack.compact.flatten + symbols(m[1]))
+          elsif (m = line.match(GROUP_BLOCK_RE))
+            stack.push(symbols(m[1]))
+          elsif line.match?(END_RE)
+            stack.pop if stack.size > 1
+          elsif line.match?(GEM_RE)
+            add_gem(entries, line, stack.compact.flatten)
+          elsif line.match?(EVAL_RE)
+            glob = line[GLOB_RE, 1] || glob
+            eval_files(line, glob, dir).each do |path|
+              next if depth >= MAX_DEPTH || !seen.add?(path)
+              inner = read_file(path)
+              walk(inner, File.dirname(path), entries, stack.compact.flatten, seen, depth + 1) if inner
+              seen.delete(path)
+            end
+          elsif line.match?(GLOB_RE)
+            glob = line[GLOB_RE, 1]
+            push_do_or_statement(stack, line)
+          else
+            push_do_or_statement(stack, line)
+          end
+        end
+      end
+
+      def read_file(path)
+        File.read(path)
+      rescue SystemCallError
+        nil
+      end
+
+      def push_do_or_statement(stack, line)
+        if line.match?(STATEMENT_RE)
+          stack.push(nil) unless line.match?(/\bend\s*\z/)
+        elsif line.match?(DO_BLOCK_RE)
+          stack.push(nil)
+        end
+      end
+
+      # 行内 eval_gemfile "path" / Dir.glob(...) 経由の eval_gemfile f を実ファイルに解決する
+      def eval_files(line, glob, dir)
+        return [] unless dir
+        m = line.match(EVAL_RE)
+        pattern = m[1] || glob
+        return [] unless pattern
+        File.expand_path(pattern, dir).then { |p| Dir.glob(p).sort }.select { File.file?(_1) }.map { File.realpath(_1) }
+      end
+
+      # コメントを除き、行末が , か \ の行は次の行と連結する
+      def logical_lines(src)
+        out = []
+        buf = nil
+        src.each_line do |raw|
+          line = raw.sub(/(?<!["'\w])#.*/, "").rstrip
+          if buf
+            buf = "#{buf} #{line.strip}"
+          else
+            buf = line
+          end
+          if buf.end_with?(",") || buf.end_with?("\\")
+            buf = buf.chomp("\\")
+            next
+          end
+          out << buf
+          buf = nil
+        end
+        out << buf if buf
+        out
+      end
+
+      def add_gem(entries, line, block_groups)
+        m = line.match(GEM_RE) or return
+        name = m[1]
+        groups = (block_groups + inline_groups(line)).uniq
+        req = require_opt(line)
+        if (old = entries[name])
+          # if/else などで複数宣言されたら、全ての宣言が group 付きのときだけ group 付きとみなす
+          groups = (old.groups.empty? || groups.empty?) ? [] : (old.groups | groups)
+          req = nil unless old.require == req
+        end
+        entries[name] = Entry.new(name: name, groups: groups, require: req)
+      end
+
+      def symbols(str)
+        found = []
+        str.scan(PERCENT_RE) { |(body)| found.concat(body.split) }
+        rest = str.gsub(PERCENT_RE, " ")
+        found + rest.scan(/:(\w+)|["'](\w+)["']/).map { |a, b| a || b }
+      end
+
+      def inline_groups(line)
+        m = line.match(/(?:\bgroups?:|:groups?\s*=>)\s*(\[[^\]]*\]|%[iIwW][\[(][^\])]*[\])]|:\w+|["']\w+["'])/)
+        m ? symbols(m[1]) : []
+      end
+
+      def require_opt(line)
+        m = line.match(/(?:\brequire:|:require\s*=>)\s*(false|nil|true|\[[^\]]*\]|%[iIwW][\[(][^\])]*[\])]|"[^"]*"|'[^']*')/)
+        return nil unless m
+        v = m[1]
+        return false if v == "false"
+        return nil if v == "nil" || v == "true"
+        return v[PERCENT_RE, 1].split if v.start_with?("%")
+        v.scan(/["']([^"']*)["']/).flatten
+      end
+    end
+  end
+end

data/lib/hayaoki/boot_report/report.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hayaoki
+  module BootReport
+    # 集計結果。to_h は JSON.generate に渡せる値 (String キーの Hash / Array / 数値 / nil) だけで作る。
+    class Report
+      ATTRS = %i[condition runs failed phases categories gems files initializers app_initializer_times on_loads eager_namespaces false_require threads
+                 ruby features meta warnings].freeze
+      attr_reader(*ATTRS)
+
+      def initialize(**kw)
+        unknown = kw.keys - ATTRS
+        raise ArgumentError, "unknown keys: #{unknown.inspect}" unless unknown.empty?
+        ATTRS.each { |a| instance_variable_set(:"@#{a}", kw[a]) }
+      end
+
+      def to_h
+        ATTRS.to_h { |a| [a.to_s, public_send(a)] }
+      end
+    end
+  end
+end