raider_reporter 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda0a98d0886eefbfd851be91d57c881e74abee367956b0272fc9b7a464045cf
-  data.tar.gz: 8012de5d41e890b7dae144ab5f208c20ed2ffa94736645a4308901f6abe24174
+  metadata.gz: 8f4191162d0ff126c9b45a552005131bc1c93b9c2c4abf97d8ae347bd8f9d21d
+  data.tar.gz: f1537e8415dee111fd49a2005e88282a34b2f0279ba74945aacab16034531f80
 SHA512:
-  metadata.gz: fa44978dfb6d93f9bbb316fe36d837b3ecb1ae668c7292b7f7e6ac345646b4c9099dd30375d8881e466f8f21eeb4ae6ae01d53e76652f975ffeaaa83b263939c
-  data.tar.gz: 6a43fa45d7a90997e64e95b9f5e40e978c398343695ce74950809f9cadbafd7420edce162c4560d01dd67892861b61180c5c7938afc2cf28a6191f1d1e18a54b
+  metadata.gz: 7763eb9aecea9e4c65d6727bf02be613720eb994bbd763f1755d23073f852faf5bcb4ca5986954a1327b80ce3a2d67b1a147f33c64cede3ab5318304897542a2
+  data.tar.gz: f06d92ce870157d73411f53ad368ecd6a01ce23294df319d49e7028f3d29d15677a8087c39c116a3d939fb58c6c0d5681aab286490e3fe94890771597438a540

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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
+- Videos get their own size cap, `config.max_video_bytes` (default 50 MB); the 5 MB `max_attachment_bytes` still applies to everything else. A video over its cap is skipped with a warning
+- Uploads keep non-video attachments (screenshots, logs) first; videos then fill whatever room is left in the upload budget. A video that does not fit is skipped and later, smaller ones are still tried
+- The Cucumber formatter works on Cucumber 12, which removed `config.strict`: it no longer logs `undefined method 'strict'` and keeps its failure counts (Cucumber 10 and 11 behave as before)
+- No breaking changes
+
 ## 0.9.0 — 2026-10-24
 
 - `raider-reporter gate` waits for the Raider quality gate verdict of the CI build (`GET /api/v1/builds/gate`, every 10 seconds, up to `RAIDER_GATE_TIMEOUT` seconds, default 600, 1–3600) and exits 0 when the gate passed or the project has no gate rules, 1 when it failed (naming the failed rules), and 2 when it gets no verdict (timeout, Raider unreachable, token rejected, build not found, any other error). 429, 5xx and network errors are retried within the time limit

data/README.md

@@ -30,7 +30,7 @@ Run `bundle exec rspec` as usual. (For Cucumber, see [Cucumber](#cucumber).) Res
 
 ## Cucumber
 
-Requirements: Cucumber 9, 10 or 11 in your own Gemfile (`gem "cucumber"`). It is not a dependency of this gem; requiring `raider_reporter/cucumber` without Cucumber raises a `LoadError` that says so. Cucumber 9.2.1 on Ruby 4 also needs `gem "logger"` in your Gemfile, because Cucumber requires it without declaring it.
+Requirements: Cucumber 9, 10, 11 or 12 (12 needs Ruby 3.3+) in your own Gemfile (`gem "cucumber"`). It is not a dependency of this gem; requiring `raider_reporter/cucumber` without Cucumber raises a `LoadError` that says so. Cucumber 9.2.1 on Ruby 4 also needs `gem "logger"` in your Gemfile, because Cucumber requires it without declaring it.
 
 ### Plugin mode (recommended)
 
@@ -120,7 +120,15 @@ end
 
 `attach` copies the file right away, so the attachment keeps the bytes the file had at that moment even if the same path is overwritten by a later example. Using a path per example (as above) still makes the files on disk easier to find.
 
-`attach` returns `true` on success. It returns `false` and prints a `[raider_reporter]` warning, never raising, if it is called outside a running example (for instance when the formatter is not loaded), if the file does not exist, or if the file is larger than 5 MB.
+`attach` returns `true` on success. It returns `false` and prints a `[raider_reporter]` warning, never raising, if it is called outside a running example (for instance when the formatter is not loaded), if the file does not exist, or if the file is larger than its size cap: 5 MB (`max_attachment_bytes`), or 50 MB for videos (`video/*`, `max_video_bytes`).
+
+Videos (`.webm`, `.mp4`) are attached the same way, for example `RaiderReporter.attach("video", path, type: :webm)`. In the local HTML report they play inline, with a download link.
+
+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
 
@@ -139,6 +147,9 @@ end
 | `clean_output_dir` | `true` | Remove the previous `run.json` and `attachments/` directory (`run-<n>.json` and `attachments-<n>/` when sharded) inside `output_dir` before writing. Nothing else in `output_dir` is touched, except a raider_reporter-written `index.html`. |
 | `html_report` | `true` | Write `index.html`, the local HTML report, into `output_dir` after each run. See [Local report](#local-report). |
 | `quarantine` | `true` when `ENV["RAIDER_QUARANTINE"]` is `1` or `true` | Fetch the quarantine list at run start and report matching failures as `quarantined`. Needs `token` and `endpoint`. See [Quarantine](#quarantine). |
+| `max_attachment_bytes` | `5 MB` | Largest non-video attachment `attach` accepts. |
+| `max_video_bytes` | `50 MB` | Largest `video/*` attachment `attach` accepts. |
+| `exec_summary_path` | `ENV["RAIDER_EXEC_SUMMARY"]` | File where the run writes its failure counts (framework failures, quarantined, errors outside tests) for `raider-reporter exec` to read when it decides the exit code. `exec` sets it for the command it runs; leave it unset otherwise. Nothing is written when it is unset. See [Quarantine](#quarantine). |
 | `environment` | `{}` | Free-form key/values stored with the run (browser, suite name, and so on). Values are JSON values: strings, booleans or numbers. |
 
 ## Local output

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/collector.rb

@@ -8,9 +8,11 @@ require "set"
 module RaiderReporter
   # Accumulates one suite run. Framework formatters call it; writers read the Run it returns.
   class Collector
-    def initialize(max_attachment_bytes:, warn:, clock: -> { Time.now.utc }, uuid: -> { SecureRandom.uuid },
+    def initialize(max_attachment_bytes:, warn:, max_video_bytes: Configuration::DEFAULT_MAX_VIDEO_BYTES,
+                   clock: -> { Time.now.utc }, uuid: -> { SecureRandom.uuid },
                    quarantine: -> { Quarantine::EMPTY })
       @max_attachment_bytes = max_attachment_bytes
+      @max_video_bytes = max_video_bytes
       @warn = warn
       @clock = clock
       @uuid = uuid
@@ -118,8 +120,9 @@ module RaiderReporter
         @warn.call("attachment #{path} no longer exists; skipped")
         return false
       end
-      if File.size(path) > @max_attachment_bytes
-        @warn.call("attachment #{path} is larger than #{@max_attachment_bytes} bytes; skipped")
+      limit = attachment.content_type.to_s.start_with?("video/") ? @max_video_bytes : @max_attachment_bytes
+      if File.size(path) > limit
+        @warn.call("attachment #{path} is larger than #{limit} bytes; skipped")
         return false
       end
       true

data/lib/raider_reporter/configuration.rb

@@ -5,9 +5,10 @@ require "raider_reporter/azure_env"
 module RaiderReporter
   class Configuration
     TRUTHY = %w[1 true].freeze
+    DEFAULT_MAX_VIDEO_BYTES = 50 * 1024 * 1024
 
     attr_accessor :token, :endpoint, :output_dir, :clean_output_dir, :html_report, :environment, :max_attachment_bytes,
-                  :quarantine, :exec_summary_path
+                  :max_video_bytes, :quarantine, :exec_summary_path
 
     def initialize(env = ENV)
       @token = AzureEnv.value(env, "RAIDER_TOKEN")
@@ -17,6 +18,7 @@ module RaiderReporter
       @html_report = true
       @environment = {}
       @max_attachment_bytes = 5 * 1024 * 1024
+      @max_video_bytes = DEFAULT_MAX_VIDEO_BYTES
       @quarantine = TRUTHY.include?(AzureEnv.value(env, "RAIDER_QUARANTINE").to_s.downcase)
       @exec_summary_path = AzureEnv.value(env, "RAIDER_EXEC_SUMMARY")
     end

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
@@ -160,8 +182,8 @@ module RaiderReporter
         return if @outcomes_broken
 
         key = "#{test_case.location}|#{test_case.name}"
-        failed = !result.ok?(strict: @config.strict)
-        flaky = !failed && @failed_before[key] && @config.strict.strict?(:flaky)
+        failed = !result_ok?(result)
+        flaky = !failed && @failed_before[key] && strict_flaky?
         @failed_before[key] ||= failed
         @outcomes[key] = failed || flaky ? true : false
       rescue StandardError => e
@@ -169,6 +191,23 @@ module RaiderReporter
         RaiderReporter.warn("#{e.class}: #{e.message}")
       end
 
+      # Cucumber 10 and 11 carry a strict configuration (config.strict) that result.ok?
+      # takes as a keyword. Cucumber 12 removed it: result.ok? takes nothing, pending and
+      # undefined always fail, and a flaky scenario never does. Detect, never compare versions.
+      def strict_configuration
+        @config.strict if @config.respond_to?(:strict)
+      end
+
+      def result_ok?(result)
+        strict = strict_configuration
+        strict ? result.ok?(strict: strict) : result.ok?
+      end
+
+      def strict_flaky?
+        strict = strict_configuration
+        strict ? strict.strict?(:flaky) : false
+      end
+
       # Scenarios that make cucumber's run fail; one error outside tests when the run
       # stopped before every scenario finished (--fail-fast) (spec §4.4).
       def record_framework_counts
@@ -242,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/cucumber.rb

@@ -5,7 +5,7 @@ begin
 rescue LoadError => e
   raise unless e.path == "cucumber"
 
-  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 12) in your Gemfile"
+  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 13) in your Gemfile"
 end
 require "raider_reporter"
 require_relative "cucumber/formatter"

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.9.0"
+  VERSION = "0.11.0"
 end

data/lib/raider_reporter/writers/html.rb

@@ -224,8 +224,11 @@ module RaiderReporter
           href = safe_href(attachment["path"])
           next unless href
 
-          if attachment["content_type"].to_s.start_with?("image/")
+          content_type = attachment["content_type"].to_s
+          if content_type.start_with?("image/")
             %(<a href="#{href}"><img loading="lazy" src="#{href}" alt="#{h(attachment['name'])}"></a>)
+          elsif content_type.start_with?("video/")
+            %(<video controls preload="metadata" src="#{href}"></video><a href="#{href}" download>#{h(attachment['name'])}</a>)
           else
             %(<a href="#{href}">#{h(attachment['name'])}</a>)
           end
@@ -280,6 +283,7 @@ module RaiderReporter
         .r p{margin:2px 0;overflow-wrap:anywhere}.n{font-weight:500}.x{color:var(--ruby);font-weight:600}
         pre{margin:4px 0;padding:8px;background:var(--card);border-radius:6px;overflow-x:auto;white-space:pre-wrap;font-size:12px}
         .a img{max-width:100%;max-height:240px;border:1px solid var(--bdr);border-radius:4px;margin-top:4px}
+        .a video{max-width:100%;max-height:360px;display:block}
         a{color:var(--ruby)}.empty{padding:24px 0;color:var(--mute)}
       CSS
 

data/lib/raider_reporter/writers/uploader.rb

@@ -48,30 +48,59 @@ module RaiderReporter
 
       private
 
-      # Keeps the leading attachments that fit the byte and count budget and
-      # rebuilds the payload without the rest, so part names stay contiguous.
-      # The local run.json is written from the original payload and keeps all.
+      # Keeps the attachments that fit the byte and count budget, non-video
+      # attachments first and videos in whatever room is left, and rebuilds the
+      # payload without the rest, so part names stay contiguous. Survivors keep
+      # their original order. The local run.json is written from the original
+      # payload and keeps all.
       def within_budget(payload)
         entries = payload.attachment_entries
-        bytes = 0
-        keep = entries.index do |entry|
-          bytes += File.size?(entry[:attachment].source_path).to_i
-          bytes > MAX_UPLOAD_ATTACHMENT_BYTES
-        end || entries.size
-        keep = [keep, MAX_UPLOAD_ATTACHMENTS].min
-        return payload if keep == entries.size
-
-        dropped = entries.size - keep
+        keep = budgeted(entries)
+        return payload if keep.size == entries.size
+
+        dropped = entries.size - keep.size
         @warn.call("not uploading #{dropped} #{dropped == 1 ? 'attachment' : 'attachments'}: over the upload " \
                    "budget of #{MAX_UPLOAD_ATTACHMENT_BYTES / (1024 * 1024)} MB / " \
                    "#{MAX_UPLOAD_ATTACHMENTS} files; they remain in #{@config.output_dir}")
-        seen = 0
         run = payload.run
         Payload.new(run.with(results: run.results.map do |result|
-          result.with(attachments: result.attachments.select { (seen += 1) <= keep })
+          result.with(attachments: result.attachments.select { |attachment| keep.key?(attachment) })
         end))
       end
 
+      # Identity-keyed set of the attachments to upload. Non-videos come first
+      # and stop at the first byte overflow; videos then fill the room left,
+      # a video that does not fit is skipped and later ones are still tried.
+      def budgeted(entries)
+        videos, others = entries.partition { |entry| video?(entry[:attachment]) }
+        keep = {}.compare_by_identity
+        bytes = 0
+        others.each do |entry|
+          bytes += size_of(entry)
+          break if bytes > MAX_UPLOAD_ATTACHMENT_BYTES || keep.size >= MAX_UPLOAD_ATTACHMENTS
+
+          keep[entry[:attachment]] = true
+        end
+        videos.each do |entry|
+          break if keep.size >= MAX_UPLOAD_ATTACHMENTS
+
+          size = size_of(entry)
+          next if bytes + size > MAX_UPLOAD_ATTACHMENT_BYTES
+
+          bytes += size
+          keep[entry[:attachment]] = true
+        end
+        keep
+      end
+
+      def video?(attachment)
+        attachment.content_type.to_s.start_with?("video/")
+      end
+
+      def size_of(entry)
+        File.size?(entry[:attachment].source_path).to_i
+      end
+
       def add_field(body, boundary, name, value)
         body << "--#{boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"\r\n\r\n".b
         body << value.to_s.b << "\r\n".b

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,8 +51,11 @@ 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,
         warn: ->(message) { warn(message) },
         quarantine: -> { quarantined_keys }
       )
@@ -70,14 +76,15 @@ module RaiderReporter
         return false
       end
 
-      limit = configuration.max_attachment_bytes
+      content_type = ContentTypes.resolve(type, path)
+      limit = attachment_limit(content_type)
       if File.size(path.to_s) > limit
         warn("attach(#{name.inspect}): file #{path} is larger than #{limit} bytes; ignored")
         return false
       end
 
       collector.attach(Attachment.new(name: name.to_s, source_path: collector.stage(path.to_s),
-                                      content_type: ContentTypes.resolve(type, path)))
+                                      content_type: content_type))
     rescue StandardError => e
       warn("attach(#{name.inspect}) failed: #{e.class}: #{e.message}")
       false
@@ -119,6 +126,10 @@ module RaiderReporter
 
     private
 
+    def attachment_limit(content_type)
+      content_type.start_with?("video/") ? configuration.max_video_bytes : configuration.max_attachment_bytes
+    end
+
     # First, so a later reporting problem cannot lose it. A failure here only means
     # no summary, and exec then keeps the command's exit code.
     def write_exec_summary

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.9.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
@@ -74,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: RSpec and Cucumber formatters that write Raider reports locally and upload
   them to Raider