rspec_telemetry 0.3.0

data/lib/rspec_telemetry/subscribers/factory_bot.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# isolated_execution_state only exists on Rails 7+; ActiveSupport::Notifications
+# works without it, so make it optional to support Rails 6.x (and earlier).
+begin
+  require "active_support/isolated_execution_state"
+rescue LoadError
+  nil
+end
+require "active_support/notifications"
+
+module RSpecTelemetry
+  module Subscribers
+    class FactoryBot
+      STACK_KEY = :rspec_telemetry_fb_stack
+
+      def initialize(recorder)
+        @recorder = recorder
+        @subscription = nil
+      end
+
+      def subscribe
+        @subscription = ActiveSupport::Notifications.subscribe("factory_bot.run_factory", self)
+      end
+
+      def unsubscribe
+        ActiveSupport::Notifications.unsubscribe(@subscription) if @subscription
+        @subscription = nil
+      end
+
+      def start(_name, _id, payload)
+        RSpecTelemetry.safely("factory_bot#start") do
+          stack.push(
+            name: payload[:name].to_s,
+            monotonic: Process.clock_gettime(Process::CLOCK_MONOTONIC),
+            child_ms: 0.0
+          )
+        end
+      end
+
+      def finish(_name, _id, payload)
+        RSpecTelemetry.safely("factory_bot#finish") do
+          frame = stack.pop
+          next unless frame
+          next unless @recorder.config.enabled && @recorder.config.capture_factory_bot
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          total = ((now - frame[:monotonic]) * 1000.0).round(3)
+          self_ms = (total - frame[:child_ms]).round(3)
+
+          parent = stack.last
+          parent[:child_ms] += total if parent
+
+          @recorder.record(
+            "factory_bot.run_factory",
+            factory: payload[:name].to_s,
+            strategy: payload[:strategy].to_s,
+            traits: Array(payload[:traits]).map(&:to_s),
+            overrides: override_names(payload[:overrides]),
+            duration_ms: total,
+            self_duration_ms: self_ms,
+            depth: stack.size,
+            parent_factory: parent && parent[:name],
+            factory_class: build_class_name(payload[:factory])
+          )
+        end
+      end
+
+      private
+
+      def override_names(overrides)
+        return [] unless overrides.is_a?(Hash)
+
+        overrides.keys.map(&:to_s)
+      end
+
+      def build_class_name(factory)
+        factory.build_class.to_s
+      rescue StandardError
+        nil
+      end
+
+      def stack
+        Thread.current[STACK_KEY] ||= []
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/summary.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "factory_aggregation"
+
+module RSpecTelemetry
+  class Summary
+    ExampleStat = Struct.new(
+      :example_id,
+      :file_path,
+      :line_number,
+      :duration_ms,
+      :factory_bot_total_ms,
+      :factory_bot_count
+    )
+
+    def initialize(config)
+      @config = config
+      @factory_acc = FactoryAggregation::Accumulator.new
+      @examples = {}
+    end
+
+    def add(event)
+      case event[:type]
+      when "factory_bot.run_factory"
+        add_factory(event)
+      when "example.finished"
+        add_example(event)
+      end
+    end
+
+    def factories
+      @factory_acc.stats
+    end
+
+    def examples
+      @examples.values
+    end
+
+    def top_factories(limit = @config.summary_limit)
+      @factory_acc.top(limit)
+    end
+
+    def slow_examples(limit = @config.summary_limit)
+      sorted = examples.sort_by { |e| -e.duration_ms.to_f }
+      threshold = @config.slow_example_threshold_ms
+      sorted = sorted.select { |e| e.duration_ms.to_f >= threshold } if threshold
+      sorted.first(limit)
+    end
+
+    private
+
+    def add_factory(event)
+      self_ms = (event[:self_duration_ms] || event[:duration_ms]).to_f
+      @factory_acc.add(
+        factory: event[:factory],
+        strategy: event[:strategy],
+        duration_ms: event[:duration_ms],
+        self_duration_ms: self_ms
+      )
+
+      example_id = event[:example_id]
+      return unless example_id
+
+      ex = (@examples[example_id] ||= ExampleStat.new(example_id, nil, nil, nil, 0.0, 0))
+      ex.factory_bot_total_ms += self_ms
+      ex.factory_bot_count += 1
+    end
+
+    def add_example(event)
+      example_id = event[:example_id]
+      return unless example_id
+
+      ex = (@examples[example_id] ||= ExampleStat.new(example_id, nil, nil, nil, 0.0, 0))
+      ex.file_path = event[:file_path]
+      ex.line_number = event[:line_number]
+      ex.duration_ms = event[:duration_ms]
+    end
+  end
+
+  module SummaryPrinter
+    module_function
+
+    def print(summary, config, io = config.summary_io)
+      return unless config.print_summary
+
+      lines = []
+      lines.concat(factory_section(summary, config))
+      lines.concat(example_section(summary, config))
+      return if lines.empty?
+
+      io.puts
+      io.puts(lines.join("\n"))
+    rescue => e
+      warn("[rspec-telemetry] failed to print summary: #{e.class}: #{e.message}")
+    end
+
+    def factory_section(summary, _config)
+      tops = summary.top_factories
+      return [] if tops.empty?
+
+      lines = ["FactoryBot telemetry summary", "", "Top factories by self time (子factoryを除く):", ""]
+      tops.each_with_index do |f, i|
+        lines << "#{i + 1}. #{f.key}"
+        lines << "   count: #{f.count}"
+        lines << "   self_total: #{round(f.self_total_ms)}ms"
+        lines << "   total: #{round(f.total_ms)}ms"
+        lines << "   avg: #{round(f.avg_ms)}ms"
+        lines << "   max: #{round(f.max_ms)}ms"
+        lines << ""
+      end
+
+      lines
+    end
+
+    def example_section(summary, _config)
+      slow = summary.slow_examples
+      return [] if slow.empty?
+
+      lines = ["Slow examples:", ""]
+      slow.each_with_index do |e, i|
+        lines << "#{i + 1}. #{e.example_id}"
+        lines << "   duration: #{round(e.duration_ms)}ms"
+        lines << "   factory_bot_total: #{round(e.factory_bot_total_ms)}ms (#{e.factory_bot_count} calls)"
+        lines << ""
+      end
+
+      lines
+    end
+
+    def round(value)
+      value.to_f.round(1)
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/app.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "tui_tui"
+
+require_relative "document"
+require_relative "theme"
+require_relative "layout"
+require_relative "pane_resizer"
+require_relative "source_view"
+require_relative "app_renderer"
+require_relative "follow_controller"
+require_relative "screen/timeline_screen"
+require_relative "screen/ranked_screen"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      # Hosts shared TUI state; per-screen row behavior lives in Screen strategies.
+      class App
+        WHEEL_ROWS = 3
+        REDRAW = "\f"
+
+        HELP = [
+          ["1 / 2 / 3", "timeline / slowest examples / factories"],
+          ["j / k   ↑ / ↓", "move"],
+          ["Space / b", "page down / up"],
+          ["g / G", "top / bottom"],
+          ["n / N", "next / prev failure (timeline)"],
+          ["Tab", "switch pane"],
+          ["J / K", "scroll detail"],
+          ["Enter", "fold / unfold this example"],
+          ["z", "collapse to examples / expand"],
+          ["f", "toggle follow"],
+          ["/", "filter timeline"],
+          ["a", "jump to example"],
+          ["s", "toggle source pane"],
+          ["S", "view full source"],
+          ["mouse", "drag the divider / source header; wheel scrolls; click to focus"],
+          ["Ctrl-L", "redraw the screen"],
+          ["?", "this help"],
+          ["q", "quit"]
+        ].freeze
+
+        attr_reader :detail_scroll
+
+        def focus = @focus_ring.current
+        def follow = @follow_ctl.active?
+
+        def initialize(
+          document,
+          depth: TuiTui::ColorDepth.detect,
+          source: nil,
+          follow: false,
+          base_dir: nil,
+          source_root: Dir.pwd
+        )
+          @document = document
+          @follow_ctl = FollowController.new(source: source, active: follow)
+          @source_view = SourceView.new(source_root: source_root, base_dir: base_dir)
+          @renderer = AppRenderer.new
+          @list = TuiTui::ScrollList.new
+          @detail_scroll = 0
+          @focus_ring = TuiTui::FocusRing.new(:timeline, :detail)
+          @modal = nil
+          @on_result = nil
+          @quit_armed = false
+          @resizer = PaneResizer.new
+          @size = nil
+          @source_visible = true
+          @view = :timeline
+          @timeline_screen = Screen::TimelineScreen.new(@document, @list)
+          @screen = @timeline_screen
+        end
+
+        def cursor = @list.cursor
+
+        def wants_tick? = @follow_ctl.wants_tick?
+
+        def redraw?(event) = event.is_a?(TuiTui::KeyEvent) && event.key == REDRAW
+
+        def update(event)
+          case event
+          when TuiTui::KeyEvent
+            @modal ? route_modal(event) : handle_key_event(event)
+          when TuiTui::MouseEvent
+            @modal ? route_modal(event) : handle_mouse(event)
+          when TuiTui::ResizeEvent
+            (@size = event.size) && self
+          when TuiTui::TickEvent
+            poll
+          else
+            self
+          end
+        end
+
+        def view(ctx)
+          size = ctx.size
+          chrome = ctx.chrome
+          @size = size
+          r = layout(size)
+          result = @renderer.render(render_state(size, r, chrome))
+          @detail_scroll = result.detail_scroll
+          result.canvas
+        end
+
+        def layout(size)
+          # Draw and hit-testing both use this geometry to keep mouse handles aligned.
+          Layout.compute(
+            size: size,
+            want_time_bar: @screen.time_bar? && !@document.end_wall_ms.nil?,
+            want_source: @screen.source? && @source_visible,
+            split_ratio: @resizer.split_ratio,
+            source_rows: @resizer.source_rows
+          )
+        end
+
+        def open_modal(widget, &on_result)
+          @modal = widget
+          @on_result = on_result
+        end
+
+        def go_to(index)
+          @list.go_to(index)
+          @detail_scroll = 0
+          # Follow resumes only when the cursor is still parked at the tail.
+          @follow_ctl.reset_stick(at_end: @list.at_end?)
+        end
+
+        private
+
+        def route_modal(event)
+          # Route both keys and clicks so modal widgets (e.g. Confirm buttons)
+          # stay interactive with the mouse instead of being ignored.
+          result = event.is_a?(TuiTui::MouseEvent) ? @modal.handle_mouse(event) : @modal.handle(event.key)
+          return self if result.nil?
+
+          @modal = nil
+          @on_result.call(result) == :quit ? :quit : self
+        end
+
+        def confirm_quit
+          open_modal(TuiTui::Confirm.new("Quit the trace viewer?", theme: Theme.base)) { |r| :quit if r == :ok }
+        end
+
+        def handle_key_event(event)
+          armed = @quit_armed
+          @quit_armed = false
+
+          case event.key
+          when TuiTui::KeyCode::CTRL_C
+            # A second consecutive Ctrl-C exits without opening the quit modal.
+            return :quit if armed
+
+            @quit_armed = true
+          when "q"
+            confirm_quit
+          when "?"
+            open_modal(TuiTui::Help.new("Keys", HELP, theme: Theme.base)) { nil }
+          when "1"
+            set_view(:timeline)
+          when "2"
+            set_view(:examples)
+          when "3"
+            set_view(:factories)
+          when "s"
+            @source_visible = !@source_visible
+          when "S"
+            view_source
+          when "j", :down
+            move(1)
+          when "k", :up
+            move(-1)
+          when " ", :pgdn
+            move(page_rows)
+          when "b", :pgup
+            move(-page_rows)
+          when "g", :home
+            go_to(0)
+          when "G", :end
+            go_to(@list.last)
+          when "\t", :backtab
+            toggle_focus
+          when "f"
+            toggle_follow
+          when "J"
+            @detail_scroll += 1
+          when "K"
+            @detail_scroll = [@detail_scroll - 1, 0].max
+          else
+            @screen.handle_key_event(event, self)
+          end
+
+          self
+        end
+
+        def set_view(view)
+          return if view == @view
+
+          @view = view
+          @screen = view == :timeline ? @timeline_screen : Screen::RankedScreen.new(@document, @list, view)
+          @screen.activate
+          go_to(0)
+        end
+
+        def move(delta) = go_to(@list.cursor + delta)
+
+        def page_rows = @size ? [layout(@size).list.rows, 1].max : 1
+
+        def toggle_focus
+          @focus_ring = @focus_ring.next
+        end
+
+        def handle_mouse(event)
+          if event.action == :wheel
+            move(event.button == :wheel_up ? -WHEEL_ROWS : WHEEL_ROWS)
+          elsif @size
+            target = @resizer.handle(event, layout(@size))
+            @focus_ring = @focus_ring.focus(target) if target
+          end
+
+          self
+        end
+
+        def toggle_follow
+          @follow_ctl.toggle(at_end: @list.at_end?)
+        end
+
+        def poll
+          # Order matters: refresh the row count after ingesting, then stick the
+          # cursor to the (new) tail.
+          @screen.refresh if @follow_ctl.drain(@document)
+          @follow_ctl.stick(@list)
+          self
+        end
+
+        def view_source
+          pager = @source_view.pager(@screen.current_source)
+          open_modal(pager) { nil } if pager
+        end
+
+        def position
+          count = @screen.count
+          return "0/0" if count.zero?
+
+          "#{@list.cursor + 1}/#{count}"
+        end
+
+        def render_state(size, regions, chrome)
+          AppRenderer::State.new(
+            size: size,
+            chrome: chrome,
+            regions: regions,
+            document: @document,
+            screen: @screen,
+            list: @list,
+            focus_ring: @focus_ring,
+            source_view: @source_view,
+            modal: @modal,
+            detail_scroll: @detail_scroll,
+            quit_armed: @quit_armed,
+            follow: @follow_ctl.active?,
+            spinner: @follow_ctl.spinner,
+            position: position
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/app_renderer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "tui_tui"
+
+require_relative "detail_pane"
+require_relative "status_line"
+require_relative "time_bar"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class AppRenderer
+        DIVIDER = TuiTui::Style.new(attrs: [:dim])
+
+        State = Data.define(
+          :size,
+          :chrome,
+          :regions,
+          :document,
+          :screen,
+          :list,
+          :focus_ring,
+          :source_view,
+          :modal,
+          :detail_scroll,
+          :quit_armed,
+          :follow,
+          :spinner,
+          :position
+        ) do
+          def focused?(pane) = focus_ring.focused?(pane)
+        end
+
+        Result = Data.define(:canvas, :detail_scroll)
+
+        def render(state)
+          canvas = TuiTui::Canvas.blank(state.size, chrome: state.chrome)
+          state.list.ensure_visible(state.regions.list.rows)
+
+          TimeBar.new(current_ms: state.screen.time_bar_current, total_ms: state.document.end_wall_ms)
+            .draw(canvas, state.regions.time) if state.regions.time
+          state.screen.draw_list(canvas, state.regions.list, focused: state.focused?(:timeline))
+          detail_scroll = draw_detail(canvas, state)
+          draw_divider(canvas, state.regions) if state.regions.divider
+          state.source_view.draw(canvas, state.regions.source, state.screen.current_source) if state.regions.source
+          draw_status(canvas, state) if state.regions.status
+          state.modal&.draw(canvas, state.size)
+
+          Result.new(canvas: canvas, detail_scroll: detail_scroll || state.detail_scroll)
+        end
+
+        private
+
+        def draw_detail(canvas, state)
+          return nil unless state.regions.detail
+
+          width = state.regions.detail.split_gutter.first.cols
+          lines = state.screen.detail_lines(width)
+          scroll = state.detail_scroll.clamp(0, [lines.length - 1, 0].max)
+          DetailPane.new(lines, scroll: scroll).draw(canvas, state.regions.detail)
+          scroll
+        end
+
+        def draw_divider(canvas, regions)
+          body = regions.body
+          rule = canvas.chrome.v
+          body.rows.times { |dr| canvas.text(body.row + dr, regions.divider, rule, DIVIDER) }
+        end
+
+        def draw_status(canvas, state)
+          notice = "Ctrl-C again to quit" if state.quit_armed
+          StatusLine
+            .new(
+              state.document,
+              position: state.position,
+              notice: notice,
+              total_ms: state.document.end_wall_ms,
+              follow: state.follow,
+              spinner: state.spinner,
+              pending: state.document.pending?,
+              mode: state.screen.title
+            )
+            .draw(canvas, state.regions.status)
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/detail_lines.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "document"
+require_relative "label"
+require_relative "format"
+require "tui_tui"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      module DetailLines
+        def self.for(entry, children: [], duration: nil, width: nil)
+          return [] if entry.nil?
+
+          lines = if entry.is_a?(Document::Action)
+            example_lines(entry, children, duration)
+          else
+            event_lines(entry)
+          end
+
+          return lines if width.nil?
+
+          lines.flat_map { |line| TuiTui::DisplayText.new(line).wrap(width, indent: "  ").map(&:to_s) }
+        end
+
+        def self.example_lines(action, children, duration)
+          lines = ["EXAMPLE", "desc: #{action.label}"]
+          lines << "at: #{action.source}" if action.source
+          lines << "status: #{action.status}" if action.status
+          took = action.duration_ms || duration
+          lines << "took: #{Format.ms(took)}" if took
+          lines.concat(exception_lines(action.exception))
+          lines.concat(children_lines(children))
+          lines
+        end
+
+        def self.exception_lines(exception)
+          return [] if exception.nil?
+
+          ["", "exception: #{exception["class"]}", "  #{exception["message"]}"]
+        end
+
+        def self.children_lines(children)
+          return [] if children.empty?
+
+          total = children.sum { |e| (e.fields["self_duration_ms"] || e.fields["duration_ms"]).to_f }
+          header = "ran #{children.size} factor#{children.size == 1 ? "y" : "ies"} (self #{Format.ms(total)}):"
+          [""] + [header] + children.map { |event| "  #{Label.plain(event)}" }
+        end
+
+        def self.event_lines(event)
+          lines = [Label.plain(event), ""]
+          event.fields.each do |key, value|
+            next if Document::INFRA_FIELDS.include?(key)
+
+            lines.concat(field_lines(key, value))
+          end
+
+          lines
+        end
+
+        def self.field_lines(key, value)
+          case value
+          when Hash
+            ["#{key}:"] + value.map { |k, v| "  #{k}: #{Format.value(v)}" }
+          when Array
+            ["#{key}:"] + value.map { |v| "  - #{Format.value(v)}" }
+          else
+            ["#{key}: #{Format.value(value)}"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/detail_pane.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "theme"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class DetailPane
+        def initialize(lines, scroll:)
+          @lines = lines
+          @scroll = scroll
+        end
+
+        def length = @lines.length
+
+        def draw(canvas, rect)
+          TuiTui::TextView.draw(canvas, rect, top: @scroll, scrollbar: Theme.base, total: @lines.length) do |index|
+            line = @lines[index]
+            next nil if line.nil?
+
+            style = index.zero? ? Theme.style(:action) : Theme.style(:dim)
+            TuiTui::Line[TuiTui::Span[line, style]]
+          end
+        end
+      end
+    end
+  end
+end