bidi2pdf 0.1.12 → 0.1.14

data/docker/entrypoint.sh

@@ -45,10 +45,10 @@ fi
 
 # DISPLAY=:99 /home/appuser/.webdrivers/chromedriver --port=33259 --whitelisted-ips=""  --allowed-origins="*" --disable-dev-shm-usage --disable-gpu  --verbose
 /home/appuser/.webdrivers/chromedriver --port=${CHROMEDRIVER_PORT} \
-                                       --headless \
-                                       --whitelisted-ips="" \
+                                       --allowed-ips="" \
                                        --allowed-origins="*" \
                                        --disable-dev-shm-usage \
                                        --disable-gpu \
                                        --user-data-dir=${USER_DATA_DIR} \
-                                       --verbose
+                                       --log-level=${CHROMEDRIVER_LOG_LEVEL:-INFO} \
+                                       --readable-timestamp

data/lib/bidi2pdf/bidi/browser_tab.rb

@@ -444,6 +444,58 @@ module Bidi2pdf
 
       # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
 
+      # Captures a screenshot of the browser tab, mirroring #print's own
+      # file/block/base64-return trichotomy.
+      #
+      # @param [String, nil] outputfile The output file for the PNG. Defaults to nil.
+      # @param [String] origin "document" (default) or "viewport" - see browsingContext.captureScreenshot.
+      # @param [String, nil] format Image format override, e.g. "image/png". Defaults to the browser's own default.
+      # @param [Hash, nil] clip A clip rectangle/element, passed through verbatim. Defaults to nil (full capture).
+      # @yield [png_base64] A block to handle the PNG content.
+      # @return [String, nil] The base64-encoded PNG content, or nil if outputfile or block is provided.
+      # rubocop:disable Metrics/AbcSize
+      def screenshot(outputfile = nil, origin: "document", format: nil, clip: nil, &block)
+        Bidi2pdf.notification_service.instrument("screenshot.bidi2pdf") do |instrumentation_payload|
+          cmd = Commands::CaptureScreenshot.new(context: browsing_context_id, origin: origin, format: format, clip: clip)
+
+          instrumentation_payload[:cmd] = cmd
+
+          client.send_cmd_and_wait(cmd) do |response|
+            if response["result"]
+              png_base64 = response.dig("result", "data")
+
+              instrumentation_payload[:png_base64] = png_base64
+
+              if outputfile
+                raise ScreenshotError, "Folder does not exist: #{File.dirname(outputfile)}" unless File.directory?(File.dirname(outputfile))
+
+                File.binwrite(outputfile, Base64.decode64(png_base64))
+                Bidi2pdf.logger.info "Screenshot saved as '#{outputfile}'."
+              end
+
+              block.call(png_base64) if block_given?
+
+              return png_base64 unless outputfile || block_given?
+            else
+              Bidi2pdf.logger.error "Error capturing screenshot: #{response}"
+            end
+          end
+        end
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Sets the browsing context's viewport - makes a headless render deterministic across
+      # machines, unlike leaving it at the browser's own default.
+      #
+      # @param [Integer] width
+      # @param [Integer] height
+      # @param [Float, nil] device_pixel_ratio Defaults to nil (browser default).
+      def set_viewport(width:, height:, device_pixel_ratio: nil)
+        cmd = Commands::SetViewport.new(context: browsing_context_id, width: width, height: height, device_pixel_ratio: device_pixel_ratio)
+        client.send_cmd_and_wait(cmd) { |response| response }
+      end
+
       private
 
       def build_command_and_extractor(print_options)

data/lib/bidi2pdf/bidi/commands/capture_screenshot.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class CaptureScreenshot
+        include Base
+
+        attr_reader :context, :origin, :format, :clip
+
+        def initialize(context:, origin: "document", format: nil, clip: nil)
+          @context = context
+          @origin = origin
+          @format = format
+          @clip = clip
+        end
+
+        def method_name
+          "browsingContext.captureScreenshot"
+        end
+
+        def params
+          {
+            context: context,
+            origin: origin,
+            format: format,
+            clip: clip
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands/set_viewport.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class SetViewport
+        include Base
+
+        attr_reader :context, :width, :height, :device_pixel_ratio
+
+        def initialize(context:, width:, height:, device_pixel_ratio: nil)
+          @context = context
+          @width = width
+          @height = height
+          @device_pixel_ratio = device_pixel_ratio
+        end
+
+        def method_name
+          "browsingContext.setViewport"
+        end
+
+        def params
+          {
+            context: context,
+            viewport: { width: width, height: height },
+            devicePixelRatio: device_pixel_ratio
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands.rb

@@ -18,6 +18,8 @@ module Bidi2pdf
       require_relative "commands/browsing_context_close"
       require_relative "commands/browsing_context_navigate"
       require_relative "commands/browsing_context_print"
+      require_relative "commands/capture_screenshot"
+      require_relative "commands/set_viewport"
       require_relative "commands/cdp_get_session"
       require_relative "commands/page_print"
       require_relative "commands/session_subscribe"

data/lib/bidi2pdf/bidi/event_manager.rb

@@ -9,8 +9,8 @@ module Bidi2pdf
           self.source_location = block.source_location
         end
 
-        def call(*args)
-          block.call(*args)
+        def call(*)
+          block.call(*)
         end
 
         def ==(other)

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -185,6 +185,8 @@ module Bidi2pdf
       cmd = [bin]
       cmd << "--port=#{@port}" unless @port.zero?
       cmd << "--headless" if @headless
+      cmd << "--log-level=#{chromedriver_log_level}"
+      cmd << "--readable-timestamp"
 
       cmd << user_data_dir_arg
       cmd.concat(process_chrome_args)
@@ -192,6 +194,15 @@ module Bidi2pdf
       cmd.join(" ")
     end
 
+    def chromedriver_log_level
+      case Bidi2pdf.logger.level
+      when Logger::DEBUG then "ALL"
+      when Logger::INFO then "INFO"
+      when Logger::WARN then "WARNING"
+      else "SEVERE"
+      end
+    end
+
     def user_data_dir_arg
       provided = @chrome_args&.find { |arg| arg.include?("--user-data-dir") }
       return provided if provided

data/lib/bidi2pdf/cli.rb

@@ -40,6 +40,8 @@ module Bidi2pdf
     option :header, type: :array, default: [], banner: "name=value", desc: "One or more custom headers", aliases: "-H"
     option :auth, type: :string, banner: "user:pass", desc: "Basic auth credentials", aliases: "-a"
     option :headless, type: :boolean, default: true, desc: "Run Chrome in headless mode"
+    option :no_sandbox, type: :boolean, default: false, desc: "Disable Chrome sandbox (needed inside containers)"
+    option :chrome_flag, type: :array, default: [], banner: "--flag[=value]", desc: "Extra Chrome flags appended to defaults", aliases: "--cf"
     option :port, type: :numeric, default: 0, desc: "Port to run ChromeDriver on (0 = auto)"
     option :wait_window_loaded,
            type: :boolean,
@@ -114,6 +116,8 @@ module Bidi2pdf
         "url" => "https://example.com",
         "output" => "output.pdf",
         "headless" => true,
+        "no_sandbox" => false,
+        "chrome_flag" => [],
         "print_options" => {
           "background" => true,
           "orientation" => "portrait",
@@ -210,6 +214,11 @@ module Bidi2pdf
       @launcher ||= begin
                       username, password = parse_auth(merged_options[:auth]) if merged_options[:auth]
 
+                      chrome_args = Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS.dup
+                      no_sandbox = merged_options[:no_sandbox] || ENV["DISABLE_CHROME_SANDBOX"] == "true"
+                      chrome_args << "--no-sandbox" if no_sandbox
+                      chrome_args.concat(Array(merged_options[:chrome_flag]))
+
                       Bidi2pdf::Launcher.new(
                         url: merged_options[:url],
                         inputfile: merged_options[:hmtl_file],
@@ -223,7 +232,8 @@ module Bidi2pdf
                         wait_window_loaded: merged_options[:wait_window_loaded],
                         wait_network_idle: merged_options[:wait_network_idle],
                         print_options: print_options,
-                        network_log_format: merged_options[:network_log_format]
+                        network_log_format: merged_options[:network_log_format],
+                        chrome_args: chrome_args
                       )
                     end
     end

data/lib/bidi2pdf/launcher.rb

@@ -38,7 +38,8 @@ module Bidi2pdf
   class Launcher
     # rubocop:disable Metrics/ParameterLists
     def initialize(url:, inputfile:, output:, cookies:, headers:, auth:, headless: true, port: 0, wait_window_loaded: false,
-                   wait_network_idle: false, print_options: {}, remote_browser_url: nil, network_log_format: :console)
+                   wait_network_idle: false, print_options: {}, remote_browser_url: nil, network_log_format: :console,
+                   chrome_args: Bidi::Session::DEFAULT_CHROME_ARGS)
       @url = url
       @inputfile = inputfile
       @port = port
@@ -54,6 +55,7 @@ module Bidi2pdf
       @remote_browser_url = remote_browser_url
       @custom_session = nil
       @network_log_format = network_log_format
+      @chrome_args = chrome_args
     end
 
     # rubocop:enable Metrics/ParameterLists
@@ -84,9 +86,9 @@ module Bidi2pdf
 
     def session
       if @remote_browser_url
-        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
+        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless, chrome_args: @chrome_args)
       else
-        @manager = ChromedriverManager.new(port: @port, headless: @headless)
+        @manager = ChromedriverManager.new(port: @port, headless: @headless, chrome_args: @chrome_args)
         @manager.start
         @manager.session
       end

data/lib/bidi2pdf/process_tree.rb

@@ -36,8 +36,8 @@ module Bidi2pdf
     end
 
     def build_process_map
-      ProcTable.ps.each_with_object({}) do |process, map|
-        map[process.pid] = { info: process, children: [] }
+      ProcTable.ps.to_h do |process|
+        [process.pid, { info: process, children: [] }]
       end
     end
 

data/lib/bidi2pdf/test_helpers/images.rb

@@ -6,6 +6,14 @@ rescue LoadError
   warn "Missing #{dep}. Add it to your Gemfile if you're using Bidi2pdf image test helpers."
 end
 
+# CVE-2026-66066 (Rails Active Storage, 2026-07-29): libvips ships loaders/savers that were never
+# fuzz-tested (SVG, JPEG XL, JPEG 2000, BMP, ICO, PSD, anything delegated to ImageMagick, ...) -
+# left reachable, a crafted file can trigger arbitrary file read or RCE. Applied once, here, for
+# every consumer of this opt-in module (Extractor, ImageSimilarityChecker, contains_pdf_image),
+# rather than left to each call site to remember - PNG/JPEG (what this gem's own screenshot/PDF
+# rendering actually produces) load through already-fuzzed loaders and are unaffected.
+Vips.block_untrusted(true) if defined?(Vips)
+
 require_relative "images/tiff_helper"
 require_relative "images/extractor"
 require_relative "images/image_similarity_checker"

data/lib/bidi2pdf/test_helpers/pdf_file_helper.rb

@@ -5,6 +5,10 @@ module Bidi2pdf
     # This module provides helper methods for handling PDF files in tests.
     # It includes methods for debugging, storing, and managing PDF files.
     module PdfFileHelper
+      def reporter
+        RSpec.configuration.reporter
+      end
+
       # Executes a block with the given PDF data and handles debugging in case of test failures.
       # If an expectation fails, the PDF data is saved to a file for debugging purposes.
       # @param [String] pdf_data the PDF data to debug
@@ -14,7 +18,7 @@ module Bidi2pdf
         yield pdf_data
       rescue RSpec::Expectations::ExpectationNotMetError => e
         failure_output = store_pdf_file pdf_data, "test-failure"
-        puts "Test failed! PDF saved to: #{failure_output}"
+        reporter.message("Test failed! PDF saved to: #{failure_output}")
         raise e
       end
 

data/lib/bidi2pdf/test_helpers/pdf_reader_utils.rb

@@ -49,7 +49,7 @@ module Bidi2pdf
         # @param pdf_data [String, StringIO, File] The PDF data to be converted.
         # @return [IO] An IO object containing the PDF data.
         def convert_data_to_io(pdf_data)
-          # rubocop:disable Lint/DuplicateBranch
+          # rubocop:disable-next Lint/DuplicateBranch
           if pdf_data.is_a?(String) && (pdf_data.start_with?("JVBERi") || pdf_data.start_with?("JVBER"))
             StringIO.new(Base64.decode64(pdf_data))
           elsif pdf_data.start_with?("%PDF-")
@@ -61,7 +61,6 @@ module Bidi2pdf
           else
             StringIO.new(pdf_data)
           end
-          # rubocop:enable Lint/DuplicateBranch
         end
       end
 

data/lib/bidi2pdf/test_helpers/pdf_text_sanitizer.rb

@@ -6,26 +6,9 @@ require "diff/lcs/hunk"
 
 module Bidi2pdf
   module TestHelpers
-    # rubocop: disable Metrics/ModuleLength
-    # Provides utilities for sanitizing and comparing PDF text content.
-    # This module includes methods for cleaning text, comparing PDF content,
-    # and reporting differences between actual and expected PDF outputs.
-    #
-    # The sanitization process includes normalizing whitespace, replacing
-    # typographic ligatures, and handling other common text formatting issues.
-    #
-    # @example Cleaning text
-    #   sanitized_text = Bidi2pdf::TestHelpers::PDFTextSanitizer.clean("Some text")
-    #
-    # @example Comparing PDF content
-    #   match = Bidi2pdf::TestHelpers::PDFTextSanitizer.match?(actual_pdf, expected_pdf)
+    # rubocop: disable-next Metrics/ModuleLength
     module PDFTextSanitizer
       class << self
-        # Cleans the given text by replacing common typographic ligatures,
-        # normalizing whitespace, and removing unnecessary characters.
-        #
-        # @param [String] text The text to clean.
-        # @return [String] The cleaned text.
         def clean(text)
           text = UnicodeUtils.nfkd(text)
 
@@ -37,157 +20,96 @@ module Bidi2pdf
               .gsub("…", "...")
               .gsub("—", "--")
               .gsub("–", "-")
-              .gsub(/\s+/, " ") # Replace all whitespace sequences with a single space
+              .gsub(/\s+/, " ")
               .strip
         end
 
-        # Cleans an array of PDF page texts by applying the `clean` method
-        # to each page's content.
-        #
-        # @param [Object] actual_pdf_thingy The PDF object to clean.
-        # @return [Array<String>] An array of cleaned page texts.
-        def clean_pages(actual_pdf_thingy)
-          Bidi2pdf::TestHelpers::PDFReaderUtils.pdf_text(actual_pdf_thingy).map { |text| clean(text) }
+        def clean_pages(pdf)
+          Bidi2pdf::TestHelpers::PDFReaderUtils.pdf_text(pdf).map { |text| clean(text) }
         end
 
-        # Cleans the given text and removes all whitespace for comparison purposes.
-        #
-        # @param [String] text The text to clean and normalize.
-        # @return [String] The cleaned text without whitespace.
         def normalize(text)
           clean(text).gsub(/\s+/, "")
         end
 
-        # Checks if the given PDF contains the expected text or pattern.
-        #
-        # @param [Object] actual_pdf_thingy The PDF object to search.
-        # @param [String, Regexp] expected The expected text or pattern.
-        # @param [Integer, nil] page_number The specific page to search (optional).
-        # @return [Boolean] `true` if the expected text is found, `false` otherwise.
         def contains?(actual_pdf_thingy, expected, page_number = nil)
-          pages = Bidi2pdf::TestHelpers::PDFReaderUtils.pdf_text(actual_pdf_thingy)
-          cleaned_pages = clean_pages(pages)
+          cleaned_pages = clean_pages(actual_pdf_thingy)
 
           return false if page_number && page_number > cleaned_pages.size
 
-          # Narrow to specific page if requested
           if page_number
             text = cleaned_pages[page_number - 1]
             return match_expected?(text, expected)
           end
 
-          # Search all pages
           cleaned_pages.any? { |page| match_expected?(page, expected) }
         end
 
-        # Matches the given text against the expected text or pattern.
-        #
-        # @param [String] text The text to match.
-        # @param [String, Regexp] expected The expected text or pattern.
-        # @return [Boolean] `true` if the text matches, `false` otherwise.
         def match_expected?(text, expected)
           return false unless text
 
           expected.is_a?(Regexp) ? text.match?(expected) : text.include?(expected.to_s)
         end
 
-        # Compares the content of two PDF objects for equality.
-        #
-        # @param [Object] actual_pdf_thingy The actual PDF object.
-        # @param [Object] expected_pdf_thingy The expected PDF object.
-        # @return [Boolean] `true` if the content matches, `false` otherwise.
         def match?(actual_pdf_thingy, expected_pdf_thingy)
-          actual = Bidi2pdf::TestHelpers::PDFReaderUtils.pdf_text actual_pdf_thingy
-          expected = Bidi2pdf::TestHelpers::PDFReaderUtils.pdf_text expected_pdf_thingy
+          cleaned_actual = clean_pages(actual_pdf_thingy)
+          cleaned_expected = clean_pages(expected_pdf_thingy)
 
-          cleaned_actual = clean_pages(actual)
-          cleaned_expected = clean_pages(expected)
-
-          # Compare without whitespace for equality check
           actual_for_comparison = cleaned_actual.map { |text| normalize(text) }
           expected_for_comparison = cleaned_expected.map { |text| normalize(text) }
 
-          if actual_for_comparison == expected_for_comparison
-            true
-          else
-            report_content_mismatch(cleaned_actual, cleaned_expected)
-            false
-          end
+          return true if actual_for_comparison == expected_for_comparison
+
+          report_content_mismatch(cleaned_actual, cleaned_expected)
+          false
         end
 
-        # Reports differences between actual and expected PDF content.
-        #
-        # @param [Array<String>] actual The actual PDF content.
-        # @param [Array<String>] expected The expected PDF content.
-        # @return [void]
         def report_content_mismatch(actual, expected)
-          puts "--- PDF content mismatch ---"
-          print_differences(actual, expected)
+          reporter.message(content_mismatch_message(actual, expected))
         end
 
-        # Prints detailed differences between actual and expected PDF content.
-        #
-        # @param [Array<String>] actual The actual PDF content.
-        # @param [Array<String>] expected The expected PDF content.
-        # @return [void]
-        def print_differences(actual, expected)
+        def content_mismatch_message(actual, expected)
+          sections = ["--- PDF content mismatch ---"]
           max_pages = [actual.length, expected.length].max
 
           (0...max_pages).each do |page_idx|
             actual_page = actual[page_idx] || "(missing page)"
             expected_page = expected[page_idx] || "(missing page)"
 
-            print_differences_for_page(actual_page, expected_page, page_idx)
+            page_message = page_difference_message(actual_page, expected_page, page_idx)
+            sections << page_message if page_message
           end
+
+          sections.join("\n")
         end
 
-        # Prints the differences between actual and expected content for a specific page.
-        # This method compares the content ignoring whitespace and, if differences are found,
-        # outputs a formatted representation of those differences.
-        #
-        # @param [String] actual_page The actual page content.
-        # @param [String] expected_page The expected page content.
-        # @param [Integer] page_idx The zero-based index of the page being compared.
-        # @return [void]
-        def print_differences_for_page(actual_page, expected_page, page_idx)
-          # Compare without whitespace
+        def page_difference_message(actual_page, expected_page, page_idx)
           actual_no_space = normalize(actual_page.to_s)
           expected_no_space = normalize(expected_page.to_s)
 
-          return if actual_no_space == expected_no_space
-
-          puts "\nPage #{page_idx + 1} differences (ignoring whitespace):"
+          return nil if actual_no_space == expected_no_space
 
-          # Create diffs between the two pages
           diffs = Diff::LCS.sdiff(expected_page, actual_page)
 
-          # Format and display the differences
-          puts format_diff_output(diffs, expected_page, actual_page)
+          [
+            "",
+            "Page #{page_idx + 1} differences (ignoring whitespace):",
+            format_diff_output(diffs, expected_page, actual_page)
+          ].join("\n")
         end
 
-        # Formats the output of differences for display.
-        #
-        # @param [Array<Diff::LCS::ContextChange>] diffs The list of differences.
-        # @param [String] expected The expected text.
-        # @param [String] actual The actual text.
-        # @return [String] The formatted differences.
         def format_diff_output(diffs, expected, actual)
-          output = []
-
           changes = group_changed_diffs(diffs)
 
-          # Output each change with context
-          changes.each do |change|
-            output += format_change expected, actual, change
-          end
+          changes.flat_map { |change| format_change(expected, actual, change) }.join("\n")
+        end
 
-          output.join("\n")
+        def reporter
+          RSpec.configuration.reporter
         end
 
         private
 
-        # Groups contiguous “real” diffs (added/removed/changed) into blocks,
-        # splitting whenever you hit an unchanged (“=”) diff.
         def group_changed_diffs(diffs)
           diffs
             .chunk_while { |_prev, curr| curr.action != "=" }
@@ -212,7 +134,6 @@ module Bidi2pdf
           }
         end
 
-        # 3. Build the final lines of output
         def build_output(snip_data, pos)
           start = snip_data[:context_start]
           ctx = snip_data[:context]
@@ -227,6 +148,5 @@ module Bidi2pdf
         end
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/bidi2pdf/test_helpers/testcontainers/chromedriver_container.rb

@@ -73,7 +73,7 @@ module Bidi2pdf
         # rubocop: enable Metrics/AbcSize
 
         def session_url(protocol: "http")
-          "#{protocol}://#{host}:#{mapped_port(port)}/session"
+          ContainerEndpoint.new(self, port).url(scheme: protocol, path: "session")
         end
       end
     end

data/lib/bidi2pdf/test_helpers/testcontainers/chromedriver_test_helper.rb

@@ -16,6 +16,10 @@ module Bidi2pdf
       end
 
       module SessionTestHelper
+        def reporter
+          RSpec.configuration.reporter
+        end
+
         def chrome_args
           chrome_args = Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS.dup
 
@@ -24,7 +28,7 @@ module Bidi2pdf
           if ENV["DISABLE_CHROME_SANDBOX"]
             chrome_args << "--no-sandbox"
 
-            puts "🚨 Chrome sandbox disabled"
+            reporter.message("🚨 Chrome sandbox disabled")
           end
           chrome_args
         end
@@ -32,6 +36,24 @@ module Bidi2pdf
         def create_session(session_url)
           Bidi2pdf::Bidi::Session.new(session_url: session_url, headless: true, chrome_args: chrome_args)
         end
+
+        # Full session/tab lifecycle in one call - create_session above only builds the session
+        # object, it never starts or closes it, and there is no after(:each) teardown for a spec
+        # that uses it directly. Mirrors Bidi2pdf::DSL.with_tab's own ensure-based teardown, but
+        # against a session_url this module already knows about (a long-lived remote-chrome
+        # reached over `session:` metadata, not a freshly spawned local chromedriver per call).
+        def with_tab(session_url)
+          session = create_session(session_url)
+          session.start
+          user_context = session.browser.create_user_context
+          tab = user_context.create_browser_window
+
+          yield tab
+        ensure
+          tab&.close
+          user_context&.close
+          session&.close
+        end
       end
     end
   end
@@ -51,7 +73,7 @@ RSpec.configure do |config|
         shared_network: config.shared_network
       )
 
-      puts "🚀 chromedriver container started for tests"
+      reporter.message("🚀 chromedriver container started for tests")
     end
   end
 
@@ -61,20 +83,31 @@ RSpec.configure do |config|
 end
 
 def stop_container(container)
-  if container&.running?
+  return unless container
 
-    if ENV["SHOW_CONTAINER_LOGS"]
-      puts "Container logs:"
-      logs_std, logs_error = container.logs
+  dump_container_logs(container) if container.running?
+  stop_running_container(container)
+  container.remove
+end
 
-      puts logs_error
-      puts logs_std
-    end
+def dump_container_logs(container)
+  return unless ENV["SHOW_CONTAINER_LOGS"]
 
-    puts "🧹 #{container.image} stopping container..."
-    container.stop
-  end
-  container&.remove
+  stdout, stderr = container.logs
+  reporter.message("Container logs:")
+  reporter.message(stderr.to_s) unless stderr.to_s.empty?
+  reporter.message(stdout.to_s) unless stdout.to_s.empty?
+end
+
+def stop_running_container(container)
+  return unless container.running?
+
+  reporter.message("🧹 #{container.image} stopping container...")
+  container.stop
+end
+
+def reporter
+  RSpec.configuration.reporter
 end
 
 def chromedriver_tests_present?