raider_reporter 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 291269e17dbda3cec36ff4822af7ba9b16b85f5f1d231eed8b96fb9b89f9e338
-  data.tar.gz: 16e1c480d70fc174b25f7b91fcd5f9b242b04f1e7b751172e796050a0c405a39
+  metadata.gz: 8f4191162d0ff126c9b45a552005131bc1c93b9c2c4abf97d8ae347bd8f9d21d
+  data.tar.gz: f1537e8415dee111fd49a2005e88282a34b2f0279ba74945aacab16034531f80
 SHA512:
-  metadata.gz: 6bc649c77eaa3a22110dd19b9a5eb28f1e60aab2d6a2877985a8254c85ad647f58d83427e298f79d48a5e420893afc12c06c54a05526a0b0488ca43c015a6510
-  data.tar.gz: 1590461029cc94956c3e28fffa9003252d8de1f064211dbcc9d3dcdfe0cbe11c4f9125fafb459978f77f082419b80c36a4702d0a7917ba480d4ed6a740a5f8fb
+  metadata.gz: 7763eb9aecea9e4c65d6727bf02be613720eb994bbd763f1755d23073f852faf5bcb4ca5986954a1327b80ce3a2d67b1a147f33c64cede3ab5318304897542a2
+  data.tar.gz: f06d92ce870157d73411f53ad368ecd6a01ce23294df319d49e7028f3d29d15677a8087c39c116a3d939fb58c6c0d5681aab286490e3fe94890771597438a540

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.11.0 — 2026-10-29
+
+- Live events: when `RAIDER_EVENTS_DIR` is set, the RSpec formatter and the Cucumber formatter/plugin append NDJSON lines (`plan`, `started`, `finished`, `done`, each with `"v":1`) to `<dir>/worker-<n>.ndjson`, where `n` is the shard index (1 without a shard). Cucumber writes `started` and `finished` once per attempt under `--retry`. The Raider desktop app tails them during a run. The files are created owner-only (0600) and a symlinked file is refused. With the variable unset, nothing changes. A write error switches the stream off after one warning and never fails the suite
+- Backtrace frames inside the project are written project-relative (`spec/login_spec.rb:12:in ...`); gem, stdlib and `vendor/` frames are unchanged
+- No breaking changes
+
 ## 0.10.0 — 2026-10-26
 
 - Video attachments play inline in the HTML report: `video/*` attachments render as a `<video controls>` player (metadata preloaded only) with a download link, instead of a plain link. Unsafe paths are still dropped

data/README.md

@@ -126,6 +126,10 @@ Videos (`.webm`, `.mp4`) are attached the same way, for example `RaiderReporter.
 
 When a run is uploaded, screenshots and other non-video attachments are sent first; videos then fill the room left in the upload budget. A video that does not fit is skipped and later, smaller videos are still tried. The local `raider-results/attachments/` folder keeps every attachment that passed its size cap.
 
+## Live events
+
+Set `RAIDER_EVENTS_DIR` and the RSpec formatter, or the Cucumber formatter/plugin, appends one JSON line per event to `<dir>/worker-<n>.ndjson` (`n` is the shard index, or 1): `plan` (the examples that will run), `started`, `finished` (status, duration, attempts; Cucumber writes one `started`/`finished` pair per `--retry` attempt) and `done`. Raider desktop tails these files for live results. Unset, nothing is written; a write error turns the stream off with one warning.
+
 ## Configuration
 
 ```ruby

data/lib/raider_reporter/app_frame.rb

@@ -17,23 +17,48 @@ module RaiderReporter
       excluded = excluded_prefixes
       Array(backtrace).each do |line|
         line = line.to_s
-        path = line[/\A(.+?):\d+/, 1]
-        next if path.nil? || path.start_with?("<internal:", "(", "-")
+        relative = relative_path(line, base, excluded)
+        return Text.utf8("#{relative}#{line[line[/\A(.+?):\d+/, 1].length..]}")[0, MAX_LENGTH] if relative
+      end
+      nil
+    end
+
+    # Rewrites every backtrace line that lies in project code to
+    # "relative/path.rb:42:in '...'"; all other lines are returned unchanged.
+    def self.relativize(backtrace, root:)
+      return [] if backtrace.nil? || backtrace.empty?
+      return backtrace if root.nil?
+
+      base = "#{File.expand_path(root.to_s).chomp("/")}/"
+      excluded = excluded_prefixes
+      Array(backtrace).map do |line|
+        text = line.to_s.scrub
+        relative = relative_path(text, base, excluded)
+        relative ? "#{relative}#{text[text[/\A(.+?):\d+/, 1].length..]}" : line
+      rescue StandardError
+        line
+      end
+    end
 
-        absolute = File.expand_path(path, base)
-        next unless File.file?(absolute)
+    # The project-relative path of a backtrace line's file, or nil when the
+    # line is not in project code.
+    def self.relative_path(line, base, excluded)
+      path = line[/\A(.+?):\d+/, 1]
+      return nil if path.nil? || path.start_with?("<internal:", "(", "-")
 
-        absolute = inside_root(absolute, base)
-        next unless absolute
-        next if excluded.any? { |prefix| absolute.start_with?(prefix) }
+      absolute = File.expand_path(path, base)
+      return nil unless File.file?(absolute)
 
-        relative = absolute.delete_prefix(base)
-        next if relative.start_with?("vendor/", ".bundle/") || relative.include?("/.bundle/")
+      absolute = inside_root(absolute, base)
+      return nil unless absolute
+      return nil if excluded.any? { |prefix| absolute.start_with?(prefix) }
 
-        return Text.utf8("#{relative}#{line[path.length..]}")[0, MAX_LENGTH]
-      end
-      nil
+      relative = absolute.delete_prefix(base)
+      return nil if relative.start_with?("vendor/", ".bundle/") || relative.include?("/.bundle/")
+
+      relative
     end
+    private_class_method :relative_path
 
     # Returns the path (rewritten under base when only the real paths match,
     # e.g. a symlinked tmpdir) or nil when it lies outside the root.

data/lib/raider_reporter/cucumber/formatter.rb

@@ -100,6 +100,7 @@ module RaiderReporter
         RaiderReporter.dry_run = config.dry_run?
         config.on_event(:test_run_started) { |_event| guard { @collector.start_run } }
         config.on_event(:test_run_started) { |event| guard { expect_cases(event.test_cases) } }
+        config.on_event(:test_run_started) { |event| guard { RaiderReporter.event_stream&.plan(event.test_cases.map { |tc| event_test(tc) }) } }
         config.on_event(:test_case_finished) { |event| count_outcome(event.test_case, event.result) }
         config.on_event(:test_case_started) { |event| guard { case_started(event.test_case) } }
         config.on_event(:test_step_finished) { |event| guard { step_finished(event.test_step, event.result) } }
@@ -113,6 +114,7 @@ module RaiderReporter
       def case_started(test_case)
         @collector.start_test
         @attempt = { test_case: test_case }
+        RaiderReporter.event_stream&.started(event_test(test_case))
       end
 
       # The first non-passed step explains why the scenario did not pass.
@@ -133,10 +135,16 @@ module RaiderReporter
         status = "quarantined" if status == "failed" && quarantined?(fields)
         key = "#{test_case.location}|#{test_case.name}"
         @attempts[key] += 1
-        # The newest attempt replaces the older one, taking its attachments with it.
-        @buffer[key] = @collector.build_test(
-          **fields, status: status, duration_ms: duration_ms(result), attempts: @attempts[key], failure: failure
-        )
+        begin
+          # The newest attempt replaces the older one, taking its attachments with it.
+          @buffer[key] = @collector.build_test(
+            **fields, status: status, duration_ms: duration_ms(result), attempts: @attempts[key], failure: failure
+          )
+        ensure
+          # Even if building the result failed: the desktop app must still see the attempt end
+          RaiderReporter.event_stream&.finished(id: fields[:identifier], status: status,
+                                                duration_ms: duration_ms(result), attempts: @attempts[key])
+        end
       end
 
       def run_finished
@@ -145,9 +153,23 @@ module RaiderReporter
         safely(nil) { record_framework_counts }
         RaiderReporter.finish!($stderr)
       ensure
+        # Even if finish! raised, so the desktop app sees the stream end
+        safely(nil) { finish_events }
         self.class.release(@config)
       end
 
+      def finish_events
+        stream = RaiderReporter.event_stream
+        stream&.done
+        stream&.close
+      end
+
+      def event_test(test_case)
+        fields = identity_for(test_case)
+        { id: fields[:identifier], file: fields[:file_path], line: fields[:line_number],
+          description: Text.utf8(test_case.name), full_name: fields[:full_name] }
+      end
+
       def expect_cases(test_cases)
         @expected_cases = test_cases.map { |test_case| "#{test_case.location}|#{test_case.name}" }.uniq.size
       end
@@ -259,11 +281,17 @@ module RaiderReporter
         Failure.new(
           message: Text.utf8("#{step_label(step_info, test_case)}\n\n#{exception.message}")[0, Text::MAX_MESSAGE],
           exception_class: Text.utf8(exception.class.name),
-          backtrace: (exception.backtrace || []).first(Text::MAX_BACKTRACE).map { |line| Text.utf8(line) },
+          backtrace: relativize(exception.backtrace || []).first(Text::MAX_BACKTRACE).map { |line| Text.utf8(line) },
           app_frame: app_frame_for(exception)
         )
       end
 
+      def relativize(backtrace)
+        AppFrame.relativize(backtrace, root: RaiderReporter.project_root || Dir.pwd)
+      rescue StandardError
+        backtrace
+      end
+
       def app_frame_for(exception)
         AppFrame.from(exception.backtrace, root: RaiderReporter.project_root || Dir.pwd)
       rescue StandardError

data/lib/raider_reporter/event_stream.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "raider_reporter/text"
+require "raider_reporter/shard_detector"
+
+module RaiderReporter
+  # Live NDJSON events for the Raider desktop app, one file per worker. On only
+  # when RAIDER_EVENTS_DIR is set. A write error switches it off after one warning.
+  class EventStream
+    VERSION = 1
+    # Owner-only, and never through a symlink someone planted in the events dir.
+    OPEN_FLAGS = File::WRONLY | File::APPEND | File::CREAT | (defined?(File::NOFOLLOW) ? File::NOFOLLOW : 0)
+
+    def self.open(warn:, env: ENV, shard: ShardDetector.new.shard)
+      dir = env["RAIDER_EVENTS_DIR"].to_s
+      return nil if dir.empty?
+
+      FileUtils.mkdir_p(dir)
+      file = File.open(File.join(dir, "worker-#{shard ? shard["index"] : 1}.ndjson"), OPEN_FLAGS, 0o600)
+      file.sync = true
+      new(file, warn: warn)
+    rescue StandardError => e
+      warn.call("events stream disabled: #{e.class}: #{e.message}")
+      nil
+    end
+
+    def initialize(file, warn:)
+      @file = file
+      @warn = warn
+    end
+
+    def plan(tests)
+      emit("plan", tests: tests.map { |test| test_fields(test) })
+    end
+
+    def started(test)
+      emit("started", **test_fields(test))
+    end
+
+    def finished(id:, status:, duration_ms:, attempts:)
+      emit("finished", id: cap(id), status: status, duration_ms: duration_ms, attempts: attempts)
+    end
+
+    def done
+      emit("done")
+    end
+
+    def close
+      @file&.close
+    rescue StandardError
+      nil
+    ensure
+      @file = nil
+    end
+
+    private
+
+    def test_fields(test)
+      { id: cap(test[:id]), file: cap(test[:file]), line: test[:line],
+        description: cap(test[:description]), full_name: cap(test[:full_name]) }
+    end
+
+    def cap(value)
+      Text.utf8(value)[0, Text::MAX_MESSAGE]
+    end
+
+    def emit(type, **fields)
+      return unless @file
+
+      @file.write("#{JSON.generate({ v: VERSION, type: type }.merge(fields))}\n")
+    rescue StandardError => e
+      @warn.call("events stream disabled: #{e.class}: #{e.message}")
+      close
+    end
+  end
+end

data/lib/raider_reporter/rspec/formatter.rb

@@ -24,10 +24,12 @@ module RaiderReporter
 
       def start(_notification)
         guard { @collector.start_run }
+        guard { RaiderReporter.event_stream&.plan(planned_tests) }
       end
 
-      def example_started(_notification)
+      def example_started(notification)
         guard { @collector.start_test }
+        guard { RaiderReporter.event_stream&.started(event_test(notification.example)) }
       end
 
       def example_passed(notification)
@@ -53,6 +55,10 @@ module RaiderReporter
       end
 
       def close(_notification)
+        guard do
+          RaiderReporter.event_stream&.done
+          RaiderReporter.event_stream&.close
+        end
         guard { RaiderReporter.finish! }
       end
 
@@ -66,17 +72,38 @@ module RaiderReporter
         failure = status == "failed" ? failure_for(execution.exception) : nil
         # The key is computed from the payload's own file_path and full_name (spec §4.2).
         status = "quarantined" if status == "failed" && @collector.quarantined?(file_path, full_name)
-        @collector.finish_test(
-          identifier: example.id,
-          full_name: full_name,
-          file_path: file_path,
-          line_number: metadata[:line_number],
-          status: status,
-          duration_ms: ((execution.run_time || 0) * 1000).round,
-          attempts: metadata.fetch(:retry_attempts, 0).to_i + 1,
-          tags: metadata.select { |key, value| value == true && !NON_TAG_KEYS.include?(key) }.keys.map(&:to_s).sort,
-          failure: failure
-        )
+        attempts = metadata.fetch(:retry_attempts, 0).to_i + 1
+        duration_ms = ((execution.run_time || 0) * 1000).round
+        begin
+          @collector.finish_test(
+            identifier: example.id,
+            full_name: full_name,
+            file_path: file_path,
+            line_number: metadata[:line_number],
+            status: status,
+            duration_ms: duration_ms,
+            attempts: attempts,
+            tags: metadata.select { |key, value| value == true && !NON_TAG_KEYS.include?(key) }.keys.map(&:to_s).sort,
+            failure: failure
+          )
+        ensure
+          # Even if recording failed: the desktop app must still see the example end
+          RaiderReporter.event_stream&.finished(id: example.id, status: status, duration_ms: duration_ms,
+                                                attempts: attempts)
+        end
+      end
+
+      # The examples this run will execute (after tag/line filters), in run order.
+      def planned_tests
+        world = ::RSpec.world
+        world.ordered_example_groups.flat_map(&:descendants)
+             .flat_map { |group| world.filtered_examples[group] }.map { |example| event_test(example) }
+      end
+
+      def event_test(example)
+        { id: example.id, file: example.metadata[:file_path].to_s.delete_prefix("./"),
+          line: example.metadata[:line_number], description: example.description,
+          full_name: example.full_description }
       end
 
       # Errors RSpec reported outside examples, plus one when it stopped early
@@ -91,6 +118,7 @@ module RaiderReporter
         return nil unless exception
 
         backtrace = ::RSpec.configuration.backtrace_formatter.format_backtrace(exception.backtrace || [])
+        backtrace = relativize(backtrace)
         Failure.new(
           message: utf8(exception.message)[0, MAX_MESSAGE],
           exception_class: utf8(exception.class.name),
@@ -108,6 +136,12 @@ module RaiderReporter
         exception.all_exceptions.first&.backtrace
       end
 
+      def relativize(backtrace)
+        AppFrame.relativize(backtrace, root: RaiderReporter.project_root || Dir.pwd)
+      rescue StandardError
+        backtrace
+      end
+
       def app_frame_for(exception)
         AppFrame.from(raw_backtrace(exception), root: RaiderReporter.project_root || Dir.pwd)
       rescue StandardError

data/lib/raider_reporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaiderReporter
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/raider_reporter.rb

@@ -16,6 +16,7 @@ require_relative "raider_reporter/writers/local"
 require_relative "raider_reporter/writers/html"
 require_relative "raider_reporter/ci_detector"
 require_relative "raider_reporter/shard_detector"
+require_relative "raider_reporter/event_stream"
 require_relative "raider_reporter/writers/uploader"
 require_relative "raider_reporter/comment/summary_client"
 require_relative "raider_reporter/comment/github_client"
@@ -23,7 +24,7 @@ require_relative "raider_reporter/comment/azure_client"
 
 module RaiderReporter
   class << self
-    attr_reader :collector, :project_root
+    attr_reader :collector, :project_root, :event_stream
 
     def configuration
       @configuration ||= Configuration.new
@@ -39,6 +40,8 @@ module RaiderReporter
     def reset!
       @dry_run = false
       @collector&.cleanup
+      @event_stream&.close
+      @event_stream = nil
       @configuration = nil
       @collector = nil
       @project_root = nil
@@ -48,6 +51,8 @@ module RaiderReporter
     def start_collector!
       @dry_run = false
       @project_root = Dir.pwd
+      @event_stream&.close
+      @event_stream = EventStream.open(warn: ->(message) { warn(message) })
       @collector = Collector.new(
         max_attachment_bytes: configuration.max_attachment_bytes,
         max_video_bytes: configuration.max_video_bytes,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Augustin Gottlieb
@@ -36,6 +36,7 @@ files:
 - lib/raider_reporter/content_types.rb
 - lib/raider_reporter/cucumber.rb
 - lib/raider_reporter/cucumber/formatter.rb
+- lib/raider_reporter/event_stream.rb
 - lib/raider_reporter/exec.rb
 - lib/raider_reporter/exec_summary.rb
 - lib/raider_reporter/gate.rb