bidi2pdf 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57c77db5483e79f4cfb2314b792fa10eecf910ee319319c8e838cce0c14dc390
-  data.tar.gz: '029c81071a16b9c8b276afda6e162811552c095dac134d3f564497f1847840a0'
+  metadata.gz: 36afd0d1f8c64ff6d72a8051785d3f65a7efcb336c07e1a6756b772ff4f17414
+  data.tar.gz: 6ecddfbacf09de3757b65009e1c41ca3cb90b8667d2fe80972200159d9f0c2b3
 SHA512:
-  metadata.gz: 2eabb11610a39980898f8f66109cc61561e47058815283d7f3db711a63ddf7e88b6bb57829dc2e39cb4f0c29811086986ff27b09c3655c8b4c1281dbfa91e1c8
-  data.tar.gz: e7d8d0099c195d503593cd45fb7a62d1f94b67fd05bba6ef64181e6d239fed23fa0a9f5f934430e1b822389ce30b294f8805f0947f85dbbdfced6e4c71a5d95b
+  metadata.gz: '0490c1e9e84467c4437eaf65128cf9adddac4509a66e7e41a791f10cb5fee6ee86d5fb821177af022a04a41441c6c57a37e8015e6a288c5e6838ecbc966bb628'
+  data.tar.gz: 935185356734aded9f38453cb2e6340501d1f99c482ffc17d62201867dd95224fe7018dfc079cfbdeed72ea44c63233fb5769987ddaa339ed7425ee6b0e281f5

data/CHANGELOG.md

@@ -8,10 +8,56 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-[unreleased]: https://github.com/dieter-medium/bidi2pdf/compare/v0.1.14..HEAD
+[unreleased]: https://github.com/dieter-medium/bidi2pdf/compare/v0.1.15..HEAD
 
 <!-- generated by git-cliff end -->
 
+## [0.1.15] - 2026-09-20
+
+### 🎨 Refactored
+
+- Remove deprecated benchmarking script
+
+### 🐛 Fixed
+
+- Handle partial Chrome session builds and cleanup
+- Ensure consistent use of alias in nginx_url helper
+- Use AtomicFixnum for thread-safe slot counting
+- Refactor Chrome session setup in specs
+- Improve session warmer configuration and timeout handling
+- Decouple chromedriver log level from logger level
+- Remove navigation ID generation for sub-resources
+- Remove redundant timeout error test
+- Improve string truncation for log safety
+- Improve release credentials check for missing keys
+- Enhance WebSocket handling for control frames and errors
+- Add chromedriver log level configuration
+- Adjust benchmark thresholds for CI environments
+- Add string truncation for safe log output
+- Set timeout for RSpec test runs
+- Prevent logging raw data URLs during navigation
+- Generate unique navigation IDs for sub-resource requests
+
+### 🔄 Changed
+
+- Merge pull request #124 from dieter-medium/feat/session-warmer
+- Merge pull request #123 from dieter-medium/feat/faster-pdf-generation
+- Merge pull request #122 from dieter-medium/chore-prepare-dev
+- Bump version to 0.1.15.pre
+
+### 🚀 Added
+
+- Implement session warmer idle time management
+- Improve session warmer threading and recovery
+- Enhance session warming and WebSocket health checks
+- Add session warmer and enhance version resolver error handling
+- Add session warming and programmatic configuration
+- Add chromedriver log level mapping and tests
+- Add release credential check for rubygems.org
+- Add navigation id handling in network events
+- Replace WebSocket client library for performance
+- Implement BufferedWebSocketClient and benchmarks
+
 ## [0.1.14] - 2026-09-19
 
 ### 🐛 Fixed
@@ -407,7 +453,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 🔄 Released
 
-- [unreleased](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.14..HEAD)
+- [unreleased](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.15..HEAD)
+- [0.1.15](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.14..v0.1.15)
 - [0.1.14](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.13..v0.1.14)
 - [0.1.13](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.12..v0.1.13)
 - [0.1.12](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.11..v0.1.12)

data/README.md

@@ -24,11 +24,12 @@ Bidi2pdf gives you **precision, flexibility, and full control**.
 7. [Architecture](#architecture)
 8. [Docker](#docker)
 9. [Configuration Options](#configuration-options)
-10. [Rails Integration](#rails-integration)
-11. [Test Helpers](#test-helpers)
-12. [Development](#development)
-13. [Contributing](#contributing)
-14. [License](#license)
+10. [Programmatic Configuration](#programmatic-configuration)
+11. [Rails Integration](#rails-integration)
+12. [Test Helpers](#test-helpers)
+13. [Development](#development)
+14. [Contributing](#contributing)
+15. [License](#license)
 
 ## ✨ Key Features
 
@@ -334,6 +335,68 @@ docker compose -f docker/docker-compose.yml down
 
 ---
 
+## 🔧 Programmatic Configuration
+
+Beyond the per-render CLI flags above, a few gem-wide defaults are set once via `Bidi2pdf.configure`:
+
+```ruby
+Bidi2pdf.configure do |config|
+  config.default_timeout = 60 # seconds - default BiDi command timeout
+  config.enable_default_logging_subscriber = true
+  config.log_truncate_limit = 200 # bytes - see below
+  config.chromedriver_log_level = "WARNING" # see below
+end
+```
+
+| Setting                             | Default | Description                                                                                                                                                                                                                      |
+|-------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `default_timeout`                   | `60`    | Default timeout (seconds) for BiDi commands that don't specify their own.                                                                                                                                                        |
+| `enable_default_logging_subscriber` | `true`  | Subscribes a default logger to the gem's internal instrumentation events.                                                                                                                                                        |
+| `log_truncate_limit`                | `200`   | Max bytes kept when logging a value that can be large (e.g. a `data:` URL) - truncated at a byte, not character, boundary.                                                                                                       |
+| `chromedriver_log_level`            | `nil`   | ChromeDriver's own `--log-level` (`"ALL"`/`"INFO"`/`"WARNING"`/`"SEVERE"`). Unset mirrors `Bidi2pdf.logger.level`; set explicitly to quiet ChromeDriver's own (often very verbose) output independently of your app's log level. |
+
+`Bidi2pdf.logger`, `Bidi2pdf.network_events_logger`, `Bidi2pdf.browser_console_logger`, and
+`Bidi2pdf.notification_service` are also configurable in the same block, for more advanced
+logging/instrumentation needs.
+
+### Pre-warmed sessions (`Bidi2pdf::SessionWarmer`)
+
+Optional. Keeps a few Chrome sessions started in the background so a render skips browser startup.
+Every slot is still used for exactly one render and then discarded - isolation is the same as
+launching a fresh Chrome per PDF.
+
+```ruby
+Bidi2pdf::SessionWarmer.configure do |c|
+  # warms c.size sessions right here, e.g. at boot
+  c.size = 2
+  c.max_idle_age = 300
+  # c.remote_browser_url = "http://remote-chrome:3000/session"
+end
+
+Bidi2pdf::SessionWarmer.with_tab do |tab|
+  tab.navigate_to(url)
+  tab.print("invoice.pdf")
+end
+
+Bidi2pdf::SessionWarmer.shutdown
+```
+
+| Setting              | Default               | Description                                                                                               |
+|----------------------|-----------------------|-----------------------------------------------------------------------------------------------------------|
+| `size`               | `1`                   | Number of sessions kept warm. With none ready, a render starts its own session as usual - it never waits. |
+| `max_idle_age`       | `300`                 | Seconds a warm session may sit unused before it is retired and replaced. `nil` disables the limit.        |
+| `headless`           | `true`                | Run Chrome headless.                                                                                      |
+| `chrome_args`        | `DEFAULT_CHROME_ARGS` | Chrome launch arguments.                                                                                  |
+| `remote_browser_url` | `nil`                 | Connect each slot to a remote chromedriver instead of starting a local one.                               |
+
+> **Security note:** an idle warm session is an open, unauthenticated automation endpoint
+> (chromedriver's port, Chrome's debugging port - loopback only for a local chromedriver) for as
+> long as it waits. `max_idle_age` bounds that window; keep it set unless the process runs somewhere
+> nothing else can reach those ports. With `remote_browser_url`, who can reach that endpoint on the
+> network is what matters, exactly as it does without the warmer.
+
+---
+
 ## 🚂 Rails Integration
 
 Rails integration is available as an additional gem:

data/lib/bidi2pdf/bidi/browser_tab.rb

@@ -533,11 +533,21 @@ module Bidi2pdf
 
         cmd = Bidi2pdf::Bidi::Commands::BrowsingContextNavigate.new url: url, context: browsing_context_id, wait: wait
 
-        client.send_cmd_and_wait(cmd) do |response|
-          Bidi2pdf.logger.debug "Navigated to page url: #{url} response: #{response}"
+        navigation_id = client.send_cmd_and_wait(cmd) do |response|
+          logged_url = url.start_with?("data:") ? "data:[#{url.bytesize} bytes]" : url
+          response_navigation_id = response.dig("result", "navigation")
+          Bidi2pdf.logger.debug "Navigated to page url: #{logged_url} navigation: #{response_navigation_id}"
+
+          response_navigation_id
         end
+
+        check_navigation_http_status(url, navigation_id)
       rescue Bidi2pdf::CmdError => e
-        msg = e.response["message"]
+        raise_navigation_error_for(url, e)
+      end
+
+      def raise_navigation_error_for(url, error)
+        msg = error.response["message"]
         case msg
         when /^net::ERR_INVALID_AUTH_CREDENTIALS/
           raise NavigationAuthError.new(url, msg)
@@ -546,10 +556,41 @@ module Bidi2pdf
         when /^net::/
           raise NavigationError, "Connection error: #{url} #{msg}"
         else
-          raise e
+          raise error
         end
       end
 
+      # browsingContext.navigate's own response never carries an HTTP status - only a
+      # network.responseCompleted event does, correlated back to this specific navigation via its
+      # "navigation" field (a Chrome/redirect-chain-wide ID, not the network request's own id).
+      # register_event_listeners already ran above, so network_events has been tracking since
+      # before the navigate command was even sent. Deliberately conservative: with no navigation
+      # ID, or no correlated *completed* request found, this stays silent rather than guessing -
+      # only a positively confirmed >= 400 status raises. max_by(&:start_timestamp) picks the last
+      # hop of a redirect chain (every hop shares the same navigation ID), matching the page the
+      # browser actually ended up on.
+      def check_navigation_http_status(url, navigation_id)
+        return unless navigation_id
+
+        final_response = correlated_navigation_response(navigation_id)
+        return unless final_response
+
+        status = final_response.http_status_code
+        return if status < 400
+
+        raise NavigationNotFoundError, "Navigation to #{url} failed: HTTP 404 Not Found" if status == 404
+
+        raise NavigationError, "Navigation to #{url} failed: HTTP #{status}"
+      end
+
+      # The last hop of a redirect chain (every hop shares the same navigation ID) - the page the
+      # browser actually ended up on, not wherever the chain started.
+      def correlated_navigation_response(navigation_id)
+        network_events.all_events
+                      .select { |event| event.navigation == navigation_id && event.http_status_code }
+                      .max_by(&:start_timestamp)
+      end
+
       def register_event_listeners
         return if @event_handlers_registered
 

data/lib/bidi2pdf/bidi/buffered_web_socket_client.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "openssl"
+require "socket"
+require "uri"
+require "websocket"
+
+module Bidi2pdf
+  module Bidi
+    # A threaded WebSocket client on the `websocket` gem's framing - the same shape Selenium's Ruby
+    # BiDi client uses. It replaces websocket-client-simple, whose reader pulled one byte at a time
+    # (`getc`, then a frame-parse attempt per byte): a printed PDF comes back as one base64 message
+    # and every network event for a `data:` navigation echoes the whole URL, so that loop ran
+    # millions of times per render - ~730 ms to decode a 700 KB frame, against ~0.5 ms in 16 KB
+    # chunks.
+    #
+    # Emits :open, :message (a WebSocket frame, payload in #data), :error and :close.
+    class BufferedWebSocketClient
+      READ_CHUNK_BYTES = 16_384
+
+      attr_reader :url
+
+      def self.connect(url, options = {})
+        client = new
+        yield client if block_given?
+        client.connect url, options
+        client
+      end
+
+      def initialize
+        @listeners = Hash.new { |hash, event| hash[event] = [] }
+        @listeners_mutex = Mutex.new
+        @write_mutex = Mutex.new
+        # Re-entrant: a failed write inside #close closes again.
+        @close_monitor = Monitor.new
+        @handshaked = false
+        @closed = false
+      end
+
+      def on(event, &listener)
+        @listeners_mutex.synchronize { @listeners[event] << listener }
+        listener
+      end
+
+      def connect(url, options = {})
+        return if @socket
+
+        @url = url
+        @socket = open_socket(URI.parse(url), options)
+        ::WebSocket.should_raise = true
+        @handshake = ::WebSocket::Handshake::Client.new url: url, headers: options[:headers]
+
+        socket = @socket # #close clears the ivar; the reader keeps its own reference
+        @thread = Thread.new { read_loop(socket, ::WebSocket::Frame::Incoming::Client.new) }
+        write @handshake.to_s
+      end
+
+      # Commands are sent from whichever thread issues them. On a plain TCP socket one IO#write is
+      # already atomic, but OpenSSL::SSL::SSLSocket#write is not, so writes share a lock for wss://.
+      def send(data, type: :text)
+        return unless open?
+
+        write ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @handshake.version).to_s
+      rescue IOError, SystemCallError, OpenSSL::SSL::SSLError => e
+        close e
+      end
+
+      # Safe from any thread, including the reader's own: the reader sees the peer hang up and
+      # closes from inside its loop, so it must neither race a caller closing at the same moment
+      # nor be killed before :close has been emitted.
+      def close(error = nil)
+        @close_monitor.synchronize do
+          return if @closed
+
+          say_goodbye unless error
+          @closed = true
+          @socket&.close
+          @socket = nil
+          emit :close, error
+          @thread.kill if @thread && @thread != Thread.current
+        end
+      end
+
+      def open? = @handshaked && !@closed
+
+      def closed? = @closed
+
+      private
+
+      def emit(event, *)
+        @listeners_mutex.synchronize { @listeners[event].dup }.each { |listener| listener.call(*) }
+      end
+
+      def write(bytes)
+        @write_mutex.synchronize { @socket&.write bytes }
+      end
+
+      def say_goodbye
+        write ::WebSocket::Frame::Outgoing::Client.new(data: nil, type: :close, version: @handshake.version).to_s if @handshaked
+      rescue IOError, SystemCallError, OpenSSL::SSL::SSLError
+        nil # the peer is already gone; there is nobody left to say goodbye to
+      end
+
+      def open_socket(uri, options)
+        tcp_socket = TCPSocket.new(uri.host, uri.port || (uri.scheme == "wss" ? 443 : 80))
+        return tcp_socket unless %w[https wss].include?(uri.scheme)
+
+        ::OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context(options)).tap do |ssl_socket|
+          ssl_socket.sync_close = true
+          ssl_socket.hostname = uri.host
+          ssl_socket.connect
+        end
+      end
+
+      def ssl_context(options)
+        ::OpenSSL::SSL::SSLContext.new.tap do |context|
+          context.ssl_version = options[:ssl_version] if options[:ssl_version]
+          context.verify_mode = options[:verify_mode] if options[:verify_mode]
+          context.cert_store = (options[:cert_store] || ::OpenSSL::X509::Store.new).tap(&:set_default_paths)
+        end
+      end
+
+      def read_loop(socket, frame)
+        until @closed
+          begin
+            consume(socket.readpartial(READ_CHUNK_BYTES), frame)
+            # Same terminal-error list as #send/#say_goodbye - Errno::ECONNRESET is already a
+            # SystemCallError, so listing it separately was both redundant and, worse, incomplete: any
+            # *other* SystemCallError or OpenSSL::SSL::SSLError fell through to the generic rescue
+            # below, which only emits :error and loops back into readpartial - on a permanently broken
+            # socket (not just ECONNRESET) that re-raises the same error every iteration forever
+            # instead of ever closing.
+          rescue IOError, SystemCallError, OpenSSL::SSL::SSLError => e # EOFError is an IOError
+            close e
+          rescue StandardError => e
+            emit :error, e
+          end
+        end
+      end
+
+      def consume(chunk, frame)
+        if @handshaked
+          frame << chunk
+        else
+          @handshake << chunk
+          return unless @handshake.finished?
+
+          @handshaked = true
+          emit :open
+          # Anything the server sent straight after its handshake response is already in this chunk.
+          frame << @handshake.leftovers unless @handshake.leftovers.to_s.empty?
+        end
+
+        while (message = frame.next)
+          dispatch_frame(message)
+        end
+      end
+
+      # WebSocket control frames (ping/pong/close) must never reach a JSON-parsing consumer -
+      # WebSocketDispatcher tries to parse every :message payload as JSON, so a raw close frame
+      # would raise JSON::ParserError, and an unanswered ping can make chromedriver or an
+      # intermediate proxy tear down an otherwise healthy connection on its own keepalive timeout.
+      def dispatch_frame(message)
+        case message.type
+        when :ping
+          send(message.data, type: :pong)
+        when :pong
+          nil
+        when :close
+          close
+        else
+          emit :message, message
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/client.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
-require "websocket-client-simple"
-
+require_relative "buffered_web_socket_client"
 require_relative "web_socket_dispatcher"
 require_relative "command_manager"
 require_relative "connection_manager"
@@ -44,11 +43,11 @@ module Bidi2pdf
 
       # Starts the WebSocket client and establishes a connection.
       #
-      # @return [WebSocket::Client::Simple] The WebSocket connection object.
+      # @return [BufferedWebSocketClient] The WebSocket connection object.
       def start
         return @socket if started?
 
-        WebSocket::Client::Simple.connect(ws_url) do |socket|
+        BufferedWebSocketClient.connect(ws_url) do |socket|
           @socket = socket
           @command_manager = CommandManager.new(@socket)
 
@@ -62,11 +61,19 @@ module Bidi2pdf
         @socket
       end
 
-      # Checks if the WebSocket client has started.
+      # Checks if the WebSocket client has started. Unlike #open?, this never flips back to false on
+      # its own if the connection dies externally - it only reflects whether #start has run.
       #
       # @return [Boolean] True if the client has started, false otherwise.
       def started? = @started
 
+      # Checks if the underlying WebSocket connection is actually open right now - false before
+      # #start, after #close, or if the reader thread noticed the connection died on its own (a
+      # real liveness signal, not just an internal "did we ever start" flag).
+      #
+      # @return [Boolean] True if the underlying socket reports itself open.
+      def open? = !!@socket&.open?
+
       # Waits until the WebSocket connection is open.
       #
       # @param [Integer] timeout The timeout duration in seconds.

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

@@ -89,6 +89,8 @@ module Bidi2pdf
             end
           when Array
             obj.map { |item| redact_sensitive_fields(item, sensitive_keys) }
+          when String
+            Bidi2pdf.truncate_for_log(obj)
           else
             obj
           end

data/lib/bidi2pdf/bidi/network_event.rb

@@ -4,7 +4,7 @@ module Bidi2pdf
   module Bidi
     class NetworkEvent
       attr_reader :id, :url, :state, :start_timestamp, :end_timestamp, :timing, :http_status_code,
-                  :http_method, :bytes_received
+                  :http_method, :bytes_received, :navigation
 
       STATE_MAP = {
         "network.responseStarted" => "started",
@@ -12,7 +12,13 @@ module Bidi2pdf
         "network.fetchError" => "error"
       }.freeze
 
-      def initialize(id:, url:, timestamp:, timing:, state:, http_status_code: nil, http_method: nil)
+      # @param [String, nil] navigation The BiDi navigation ID this request belongs to - present on
+      #   the main-frame document request, letting a caller correlate a specific
+      #   browsingContext.navigate call to the network event carrying its actual HTTP status. A
+      #   sub-resource request (an image, a script, ...) has no real BiDi navigation ID and stays
+      #   nil here - #id already distinguishes one event from another in logs, so this field is
+      #   left alone rather than filled with a value the protocol never sent.
+      def initialize(id:, url:, timestamp:, timing:, state:, http_status_code: nil, http_method: nil, navigation: nil)
         @id = id
         @url = url
         @start_timestamp = timestamp
@@ -20,6 +26,7 @@ module Bidi2pdf
         @state = map_state(state)
         @http_status_code = http_status_code
         @http_method = http_method
+        @navigation = navigation
       end
 
       def update_state(new_state, timestamp: nil, timing: nil, http_status_code: nil, bytes_received: nil)
@@ -61,6 +68,7 @@ module Bidi2pdf
           "method=#{method_str.inspect}, " \
           "url=#{@url.inspect}, " \
           "state=#{@state.inspect}, " \
+          "navigation=#{@navigation.inspect}, " \
           "#{http_status}, " \
           "bytes_received=#{bytes_str}, " \
           "start=#{start_str}, " \
@@ -76,7 +84,8 @@ module Bidi2pdf
           timing: @timing&.dup,
           state: @state,
           http_status_code: @http_status_code,
-          http_method: @http_method
+          http_method: @http_method,
+          navigation: @navigation
         ).tap do |duped|
           duped.instance_variable_set(:@end_timestamp, @end_timestamp)
           duped.instance_variable_set(:@bytes_received, @bytes_received)

data/lib/bidi2pdf/bidi/network_events.rb

@@ -41,6 +41,13 @@ module Bidi2pdf
         timing = request["timings"]
         http_method = request["method"]
 
+        # A top-level sibling of "request"/"response" in BiDi's own network.BaseParameters, not
+        # nested under either - present for the main-frame document request of a navigation, nil
+        # for an unrelated sub-resource fetch (an image, a script, ...). Lets a caller correlate a
+        # specific browsingContext.navigate call to the exact network event carrying its real HTTP
+        # status, which the navigate command's own response never includes.
+        navigation = event["navigation"]
+
         timestamp = event["timestamp"]
 
         Bidi2pdf.notification_service.instrument("network_event_received.bidi2pdf",
@@ -57,7 +64,8 @@ module Bidi2pdf
               timestamp: timestamp,
               timing: timing,
               state: method,
-              http_method: http_method
+              http_method: http_method,
+              navigation: navigation
             )
           elsif events.key?(id)
             events[id].update_state(method, timestamp: timestamp, timing: timing, http_status_code: http_status_code, bytes_received: bytes_received)

data/lib/bidi2pdf/bidi/session.rb

@@ -62,7 +62,7 @@ module Bidi2pdf
         "--disable-breakpad", # Disable the Breakpad crash-reporting library entirely
         "--enable-features=PdfOopif", # Enable out-of-process iframe (OOPIF) architecture for PDF rendering
         "--disable-features=Translate,AcceptCHFrame,MediaRouter,OptimizationHints,ProcessPerSiteUpToMainFrameThreshold,IsolateSandboxedIframes",
-        "--disable-extensions about:blank"
+        "--disable-extensions" # Don't load extensions. One switch per entry: it used to read "--disable-extensions about:blank", which Chrome rejected whole ("Ignoring switch with invalid name").
       ].freeze
 
       # @return [URI] The URI of the session.

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -194,13 +194,17 @@ module Bidi2pdf
       cmd.join(" ")
     end
 
+    # Chromedriver's own internal log verbosity is independent from this app's - defaults to
+    # mirroring Bidi2pdf.logger.level for backward compatibility, but Bidi2pdf.chromedriver_log_level
+    # lets a consumer quiet chromedriver's own (often much more verbose, e.g. full BiDi command/
+    # response dumps at its own INFO level) output without changing their app's own log level.
     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
+      Bidi2pdf.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

data/lib/bidi2pdf/notifications/logging_subscriber.rb

@@ -95,6 +95,8 @@ module Bidi2pdf
           end
         when Array
           obj.map { |item| redact_sensitive_fields(item, sensitive_keys) }
+        when String
+          Bidi2pdf.truncate_for_log(obj)
         else
           obj
         end