bidi2pdf 0.1.4 → 0.1.6

data/lib/bidi2pdf/bidi/logger_events.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "network_event"
+
+module Bidi2pdf
+  module Bidi
+    class LoggerEvents
+      attr_reader :context_id
+
+      def initialize(context_id)
+        @context_id = context_id
+      end
+
+      def handle_event(data)
+        event = data["params"]
+        method = data["method"]
+
+        if event.dig("source", "context") == context_id
+          handle_response(method, event)
+        else
+          Bidi2pdf.logger.debug "Ignoring Log event: #{method}, context_id: #{context_id}, params: #{event}"
+        end
+      rescue StandardError => e
+        Bidi2pdf.logger.error "Error handling Log event: #{e.message}\n#{e.backtrace&.join("\n")}"
+      end
+
+      def handle_response(_method, event)
+        level = resolve_log_level(event["level"])
+        text = event["text"]
+        args = event["args"] || []
+        stack_trace = event["stackTrace"]
+        timestamp = format_timestamp(event["timestamp"])
+        prefix = log_prefix(timestamp)
+
+        log_message(level, prefix, text)
+        log_args(prefix, args)
+        log_stack_trace(prefix, stack_trace) if stack_trace && level == :error
+      end
+
+      private
+
+      def log_message(level, prefix, text)
+        return unless text
+
+        Bidi2pdf.logger.send(level, "#{prefix} #{text}")
+      end
+
+      def log_args(prefix, args)
+        return if args.empty?
+
+        Bidi2pdf.logger.debug("#{prefix} Args: #{args.inspect}")
+      end
+
+      def log_stack_trace(prefix, trace)
+        formatted_trace = format_stack_trace(trace)
+        Bidi2pdf.logger.error("#{prefix} Stack trace captured:\n#{formatted_trace}")
+      end
+
+      def format_timestamp(timestamp)
+        return "N/A" unless timestamp
+
+        Time.at(timestamp.to_f / 1000).utc.strftime("%Y-%m-%d %H:%M:%S.%L UTC")
+      end
+
+      def format_stack_trace(trace)
+        trace["callFrames"].each_with_index.map do |frame, index|
+          function = frame["functionName"].to_s.empty? ? "(anonymous)" : frame["functionName"]
+          "##{index} #{function} at #{frame["url"]}:#{frame["lineNumber"]}:#{frame["columnNumber"]}"
+        end.join("\n")
+      end
+
+      def resolve_log_level(js_level)
+        case js_level
+        when "info", "warn", "error"
+          js_level.to_sym
+        else
+          :debug
+        end
+      end
+
+      def log_prefix(timestamp)
+        "[#{timestamp}][Browser Console Log]"
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_event.rb

@@ -3,7 +3,8 @@
 module Bidi2pdf
   module Bidi
     class NetworkEvent
-      attr_reader :id, :url, :state, :start_timestamp, :end_timestamp, :timing
+      attr_reader :id, :url, :state, :start_timestamp, :end_timestamp, :timing, :http_status_code,
+                  :http_method, :bytes_received
 
       STATE_MAP = {
         "network.responseStarted" => "started",
@@ -11,18 +12,22 @@ module Bidi2pdf
         "network.fetchError" => "error"
       }.freeze
 
-      def initialize(id:, url:, timestamp:, timing:, state:)
+      def initialize(id:, url:, timestamp:, timing:, state:, http_status_code: nil, http_method: nil)
         @id = id
         @url = url
         @start_timestamp = timestamp
         @timing = timing
         @state = map_state(state)
+        @http_status_code = http_status_code
+        @http_method = http_method
       end
 
-      def update_state(new_state, timestamp: nil, timing: nil)
+      def update_state(new_state, timestamp: nil, timing: nil, http_status_code: nil, bytes_received: nil)
         @state = map_state(new_state)
         @end_timestamp = timestamp if timestamp
         @timing = timing if timing
+        @http_status_code = http_status_code if http_status_code
+        @bytes_received = bytes_received if bytes_received
       end
 
       def map_state(state)
@@ -44,10 +49,23 @@ module Bidi2pdf
       def in_progress? = state == "started"
 
       def to_s
-        took_str = duration_seconds ? "took #{duration_seconds} sec" : "in progress"
-        "#<NetworkEvent id=#{@id} url=#{@url} state=#{@state} " \
-          "start=#{format_timestamp(@start_timestamp)} " \
-          "end=#{format_timestamp(@end_timestamp)} #{took_str}>"
+        took_str = duration_seconds ? "#{duration_seconds.round(2)} sec" : "in progress"
+        http_status = @http_status_code ? "HTTP #{@http_status_code}" : "HTTP (N/A)"
+        start_str = format_timestamp(@start_timestamp) || "N/A"
+        end_str = format_timestamp(@end_timestamp) || "N/A"
+        method_str = @http_method || "N/A"
+        bytes_str = @bytes_received ? "#{@bytes_received} bytes" : "0 bytes"
+
+        "#<NetworkEvent " \
+          "id=#{@id.inspect}, " \
+          "method=#{method_str.inspect}, " \
+          "url=#{@url.inspect}, " \
+          "state=#{@state.inspect}, " \
+          "#{http_status}, " \
+          "bytes_received=#{bytes_str}, " \
+          "start=#{start_str}, " \
+          "end=#{end_str}, " \
+          "duration=#{took_str}>"
       end
     end
   end

data/lib/bidi2pdf/bidi/network_event_formatters/network_event_console_formatter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module NetworkEventFormatters
+      # rubocop: disable  Metrics/AbcSize
+      class NetworkEventConsoleFormatter
+        include NetworkEventFormatterUtils
+
+        attr_reader :color_enabled
+
+        # ANSI styles
+        RESET = "\e[0m"
+        BOLD = "\e[1m"
+        DIM = "\e[2m"
+        RED = "\e[31m"
+        GREEN = "\e[32m"
+        YELLOW = "\e[33m"
+        CYAN = "\e[36m"
+        GRAY = "\e[90m"
+
+        def initialize(color: true)
+          @color_enabled = color
+        end
+
+        def log(events)
+          events.each { |event| pretty_log(event).each_line { |line| Bidi2pdf.network_events_logger.info(line.chomp) } }
+        end
+
+        def pretty_log(event)
+          status = event.http_status_code ? "HTTP #{event.http_status_code}" : "pending"
+          status_color = color_for_status(event.http_status_code)
+          start = event.format_timestamp(event.start_timestamp)
+          finish = event.end_timestamp ? event.format_timestamp(event.end_timestamp) : dim("...")
+          duration = event.duration_seconds ? cyan("#{event.duration_seconds}s") : dim("in progress")
+          timing_details = format_timing(event)
+          bytes = event.bytes_received ? format_bytes(event.bytes_received) : dim("N/A")
+          displayed_url = shorten_url(event.url)
+
+          <<~LOG.strip
+            #{bold("┌─ Network Event ──────────────────────────────────────")}
+            #{bold("│ Request: ")}#{event.http_method || "?"} #{displayed_url}#{"          "}
+            #{bold("│ State:   ")}#{event.state}
+            #{bold("│ Status:  ")}#{status_color}#{status}#{reset}
+            #{bold("│ Started: ")}#{start}
+            #{bold("│ Ended:   ")}#{finish}
+            #{bold("│ Duration:")} #{duration}
+            #{bold("│ Received:")} #{bytes}
+            #{timing_details}
+            #{bold("└──────────────────────────────────────────────────────")}
+          LOG
+        end
+
+        private
+
+        def format_timing(event)
+          return "" unless event.timing.is_a?(Hash)
+
+          keys = %w[
+          requestTime proxyStart proxyEnd dnsStart dnsEnd connectStart connectEnd
+          sslStart sslEnd workerStart workerReady sendStart sendEnd receiveHeadersEnd
+        ]
+
+          visible = keys.map do |key|
+            next unless event.timing[key]
+
+            label = key.gsub(/([A-Z])/, ' \1').capitalize
+            "#{dim("│")} #{label.ljust(20)}: #{event.timing[key].round(2)} ms#{reset}"
+          end.compact
+
+          return "" if visible.empty?
+
+          [dim("│").to_s, dim("│ Timing Phases:").to_s].concat(visible).join("\n")
+        end
+
+        # === Color Helpers ===
+
+        def color_for_status(code)
+          return gray unless code
+
+          case code.to_i
+          when 200..299 then green
+          when 300..499 then yellow
+          when 500..599 then red
+          else gray
+          end
+        end
+
+        def bold(str) = color_enabled ? "#{BOLD}#{str}#{RESET}" : str
+
+        def dim(str) = color_enabled ? "#{DIM}#{str}#{RESET}" : str
+
+        def green(str = "") = color_enabled ? "#{GREEN}#{str}" : str
+
+        def yellow(str = "") = color_enabled ? "#{YELLOW}#{str}" : str
+
+        def red(str = "") = color_enabled ? "#{RED}#{str}" : str
+
+        def cyan(str = "") = color_enabled ? "#{CYAN}#{str}" : str
+
+        def gray(str = "") = color_enabled ? "#{GRAY}#{str}" : str
+
+        def reset = color_enabled ? RESET : ""
+
+        # rubocop: enable  Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_event_formatters/network_event_formatter_utils.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Bidi2pdf
+  module Bidi
+    module NetworkEventFormatters
+      module NetworkEventFormatterUtils
+        def format_bytes(size)
+          return "N/A" unless size.is_a?(Numeric)
+
+          units = %w[B KB MB GB TB]
+          idx = 0
+          while size >= 1024 && idx < units.size - 1
+            size /= 1024.0
+            idx += 1
+          end
+          format("%<size>.2f %<unit>s", size: size, unit: units[idx])
+        end
+
+        def parse_timing(event)
+          return [] unless event.timing.is_a?(Hash)
+
+          keys = %w[
+          requestTime proxyStart proxyEnd dnsStart dnsEnd connectStart connectEnd
+          sslStart sslEnd workerStart workerReady sendStart sendEnd receiveHeadersEnd
+        ]
+
+          keys.filter_map do |key|
+            next unless event.timing[key]
+
+            label = key.gsub(/([A-Z])/, ' \1').capitalize
+            { label: label, key: key, ms: event.timing[key].round(2) }
+          end
+        end
+
+        def format_timestamp(timestamp)
+          return "N/A" unless timestamp
+
+          Time.at(timestamp.to_f / 1000).utc.strftime("%Y-%m-%d %H:%M:%S.%L UTC")
+        end
+
+        def shorten_url(url)
+          sanitized_url = CGI.escapeHTML(url)
+
+          return sanitized_url unless sanitized_url.start_with?("data:text/html")
+
+          "data:text/html,..."
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_event_formatters/network_event_html_formatter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module NetworkEventFormatters
+      class NetworkEventHtmlFormatter
+        include NetworkEventFormatterUtils
+
+        def render(events)
+          return unless Bidi2pdf.network_events_logger.info?
+
+          <<~HTML
+            <!DOCTYPE html>
+            <html lang="en" data-bs-theme="light">
+            <head>
+              <meta charset="UTF-8">
+              <title>Network Events</title>
+              <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+              <style>
+                body { font-family: monospace; padding: 2rem; }
+                .event { background: var(--bs-body-bg); border: 1px solid var(--bs-border-color); padding: 1rem; margin-bottom: 2rem; border-radius: .5rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+                .bar-container { position: relative; height: 20px; background: var(--bs-secondary-bg); border-radius: 4px; }
+                .bar { position: absolute; top: 0; height: 100%; background-color: #0d6efd; opacity: 0.8; }
+                .toc a { text-decoration: none; display: block; margin-bottom: 0.5rem; }
+
+                @media print {
+                  .no-break {
+                    page-break-inside: avoid;
+                  }
+            #{"    "}
+            #{"     "}
+                  .form-select, .form-label, #theme-select {
+                    display: none !important; /* Hide theme selector when printing */
+                  }
+                }
+
+                .event {
+                  word-break: break-word;
+                  overflow-wrap: anywhere;
+                }
+              </style>
+              <script>
+                function toggleTheme(value) {
+                  document.documentElement.setAttribute('data-bs-theme', value);
+                }
+              </script>
+            </head>
+            <body>
+              <h1>Network Events</h1>
+              <div class="mb-4">
+                <label for="theme-select" class="form-label">Theme:</label>
+                <select id="theme-select" class="form-select w-auto d-inline-block" onchange="toggleTheme(this.value)">
+                  <option value="light">Light</option>
+                  <option value="dark">Dark</option>
+                </select>
+              </div>
+
+              <h2>Index</h2>
+              <div class="toc mb-4">
+                #{events.map.with_index { |e, i| toc_entry(e, i) }.join("\n")}
+              </div>
+
+              #{events.map.with_index { |e, i| render_event(e, i) }.join("\n")}
+            </body>
+            </html>
+          HTML
+        end
+
+        def toc_entry(event, index)
+          "<a href=\"#event-#{index}\">[#{index + 1}] #{event.http_method} #{event.url}</a>"
+        end
+
+        # rubocop: disable Metrics/AbcSize
+        def render_event(event, index)
+          timing = parse_timing(event)
+          duration = event.duration_seconds || 0
+          duration_str = event.in_progress? ? "in progress" : "#{duration}s"
+          status = event.http_status_code || "?"
+          method = event.http_method || "?"
+          start = format_timestamp(event.start_timestamp)
+          finish = event.end_timestamp ? format_timestamp(event.end_timestamp) : "..."
+          bytes = event.bytes_received ? format_bytes(event.bytes_received) : "N/A"
+          bars = render_timing_bars(timing)
+          displayed_url = shorten_url(event.url)
+
+          <<~HTML
+            <div class="event no-break" id="event-#{index}">
+              <div><strong>Request:</strong> #{method} #{displayed_url}</div>
+              <div><strong>Status:</strong> HTTP #{status}</div>
+              <div><strong>State:</strong> #{event.state}</div>
+              <div><strong>Start:</strong> #{start}</div>
+              <div><strong>End:</strong> #{finish}</div>
+              <div><strong>Duration:</strong> #{duration_str}</div>
+              <div><strong>Received:</strong> #{bytes}</div>
+              #{bars}
+            </div>
+          HTML
+        end
+
+        # rubocop: enable Metrics/AbcSize
+
+        def render_timing_bars(timing)
+          return "" if timing.empty?
+
+          max_ms = timing.map { |t| t[:ms] }.max
+          scale = max_ms.zero? ? 0 : 100.0 / max_ms
+
+          bars = timing.map do |t|
+            width = (t[:ms] * scale).clamp(1, 100).round(2)
+            <<~HTML
+              <div>
+                <small>#{t[:label]} (#{t[:ms]} ms)</small>
+                <div class="bar-container mb-2">
+                  <div class="bar" style="width: #{width}%"></div>
+                </div>
+              </div>
+            HTML
+          end
+
+          "<div class=\"mt-3\"><strong>Timing Waterfall</strong>#{bars.join}</div>"
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_event_formatters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module NetworkEventFormatters
+      require_relative "network_event_formatters/network_event_formatter_utils"
+      require_relative "network_event_formatters/network_event_console_formatter"
+      require_relative "network_event_formatters/network_event_html_formatter"
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_events.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "network_event"
+require_relative "network_event_formatters"
 
 module Bidi2pdf
   module Bidi
     class NetworkEvents
-      attr_reader :context_id, :events
+      attr_reader :context_id, :events, :network_event_formatter
 
       def initialize(context_id)
         @context_id = context_id
         @events = {}
+        @network_event_formatter = NetworkEventFormatters::NetworkEventConsoleFormatter.new
       end
 
       def handle_event(data)
@@ -30,23 +32,28 @@ module Bidi2pdf
         return unless event && event["request"]
 
         request = event["request"]
+        response = event["response"]
+        http_status_code = response&.dig("status")
+        bytes_received = response&.dig("bytesReceived")
 
         id = request["request"]
         url = request["url"]
         timing = request["timings"]
+        http_method = request["method"]
 
         timestamp = event["timestamp"]
 
-        if method == "network.responseStarted"
+        if method == "network.beforeRequestSent"
           events[id] ||= NetworkEvent.new(
             id: id,
             url: url,
             timestamp: timestamp,
             timing: timing,
-            state: method
+            state: method,
+            http_method: http_method
           )
         elsif events.key?(id)
-          events[id].update_state(method, timestamp: timestamp, timing: timing)
+          events[id].update_state(method, timestamp: timestamp, timing: timing, http_status_code: http_status_code, bytes_received: bytes_received)
         else
           Bidi2pdf.logger.warn "Received response for unknown request ID: #{id}, URL: #{url}"
         end
@@ -58,7 +65,19 @@ module Bidi2pdf
         events.values.sort_by(&:start_timestamp)
       end
 
-      def wait_until_all_finished(timeout: 10, poll_interval: 0.1)
+      def log_network_traffic(format: :console)
+        format = format.to_sym
+
+        if format == :console
+          NetworkEventFormatters::NetworkEventConsoleFormatter.new.log all_events
+        elsif format == :html
+          NetworkEventFormatters::NetworkEventHtmlFormatter.new.render(all_events)
+        else
+          raise ArgumentError, "Unknown network event format: #{format}"
+        end
+      end
+
+      def wait_until_network_idle(timeout: 10, poll_interval: 0.1)
         start_time = Time.now
 
         loop do

data/lib/bidi2pdf/bidi/session.rb

@@ -10,7 +10,7 @@ require_relative "user_context"
 module Bidi2pdf
   module Bidi
     class Session
-      SUBSCRIBE_EVENTS = %w[log script].freeze
+      SUBSCRIBE_EVENTS = %w[script].freeze
       DEFAULT_CHROME_ARGS = %w[--disable-gpu --disable-popup-blocking --disable-hang-monitor].freeze
 
       attr_reader :session_uri, :started, :chrome_args

data/lib/bidi2pdf/cli.rb

@@ -31,6 +31,10 @@ module Bidi2pdf
     USAGE
 
     option :url, desc: "The URL to render"
+    # of course, it's possible to render a local file via: --url file:///path/to/the/file.html
+    # but this should showcase the scenario that you render a string within ruby as pdf without the need
+    # to store it on disc
+    option :html_file, desc: "The local HTML file to render"
     option :output, default: "output.pdf", desc: "Filename for the output PDF", aliases: "-o"
     option :cookie, type: :array, default: [], banner: "name=value", desc: "One or more cookies", aliases: "-C"
     option :header, type: :array, default: [], banner: "name=value", desc: "One or more custom headers", aliases: "-H"
@@ -47,6 +51,12 @@ module Bidi2pdf
     option :log_level,
            type: :string,
            default: "info", enum: %w[debug info warn error fatal unknown], desc: "Set log level"
+    option :log_network_traffic, type: :boolean, default: false, desc: "Log network traffic", aliases: "-n"
+    option :network_log_format,
+           type: :string,
+           default: "console",
+           enum: %w[console pdf],
+           desc: "Choose network log format: console or pdf", aliases: "-f"
 
     option :background, type: :boolean, default: true, desc: "Print background graphics"
     option :margin_top, type: :numeric, default: 1.0, desc: "Top margin in inches"
@@ -60,10 +70,16 @@ module Bidi2pdf
     option :scale, type: :numeric, default: 1.0, desc: "Scale between 0.1 and 2.0"
     option :shrink_to_fit, type: :boolean, default: true, desc: "Shrink content to fit page"
 
+    class << self
+      def exit_on_failure?
+        true
+      end
+    end
+
     def render
       load_config
 
-      validate_required_options! :url
+      validate_required_options!
 
       configure
 
@@ -115,9 +131,11 @@ module Bidi2pdf
       YAML.load_file(options[:config]).transform_keys(&:to_sym)
     end
 
-    def validate_required_options!(*keys)
-      keys.each do |key|
-        raise Thor::Error, "Missing required option: --#{key.to_s.tr("_", "-")}" unless merged_options[key]
+    def validate_required_options!
+      if merged_options[:url].nil? && merged_options[:html_file].nil?
+        raise Thor::Error, "Missing required option --url or --html_file needs to be specified"
+      elsif merged_options[:html_file] && !File.readable?(merged_options[:html_file])
+        raise Thor::Error, "HTML file '#{merged_options[:html_file]}' not found or not readable"
       end
     end
 
@@ -182,6 +200,7 @@ module Bidi2pdf
 
                       Bidi2pdf::Launcher.new(
                         url: merged_options[:url],
+                        inputfile: merged_options[:hmtl_file],
                         output: merged_options[:output],
                         cookies: parse_key_values(merged_options[:cookie]),
                         headers: parse_key_values(merged_options[:header]),
@@ -191,7 +210,8 @@ module Bidi2pdf
                         headless: merged_options[:headless],
                         wait_window_loaded: merged_options[:wait_window_loaded],
                         wait_network_idle: merged_options[:wait_network_idle],
-                        print_options: print_options
+                        print_options: print_options,
+                        network_log_format: merged_options[:network_log_format]
                       )
                     end
     end
@@ -201,6 +221,9 @@ module Bidi2pdf
     def configure
       Bidi2pdf.configure do |config|
         config.logger.level = log_level
+
+        config.network_events_logger.level = Logger::INFO if merged_options[:log_network_traffic]
+
         config.default_timeout = merged_options[:default_timeout]
 
         Chromedriver::Binary.configure do |c|

data/lib/bidi2pdf/dsl.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "bidi2pdf"
+
+module Bidi2pdf
+  module DSL
+    # rubocop: disable  Metrics/AbcSize
+    def self.with_tab(remote_browser_url: nil, port: 0, headless: true, chrome_args: Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS.dup)
+      manager = nil
+      session = nil
+      tab = nil
+
+      begin
+        session = if remote_browser_url
+                    Bidi2pdf::Bidi::Session.new(
+                      session_url: remote_browser_url,
+                      headless: true, # remote is always headless
+                      chrome_args: chrome_args
+                    )
+                  else
+                    manager = Bidi2pdf::ChromedriverManager.new(port: port, headless: headless)
+                    manager.start
+                    manager.session
+                  end
+
+        session.start
+        session.client.on_close { Bidi2pdf.logger.info "WebSocket session closed" }
+
+        browser = session.browser
+        context = browser.create_user_context
+        window = context.create_browser_window
+        tab = window.create_browser_tab
+
+        yield(tab)
+      ensure
+        tab&.close
+        window&.close
+        session&.close
+        manager&.stop
+      end
+    end
+
+    # rubocop: enable  Metrics/AbcSize
+  end
+end