log_bench 0.1.0

data/lib/log_bench/app/renderer/request_list.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    module Renderer
+      class RequestList
+        include Curses
+
+        # Layout constants
+        HEADER_Y_OFFSET = 2
+        COLUMN_HEADER_Y = 1
+        MIN_FILTER_X_POSITION = 20
+        FILTER_X_MARGIN = 3
+
+        # Column widths
+        METHOD_WIDTH = 8
+        STATUS_WIDTH = 8
+        PATH_MARGIN = 27
+
+        # Color constants
+        HEADER_CYAN = 1
+        DEFAULT_WHITE = 2
+        WARNING_YELLOW = 4
+        SELECTION_HIGHLIGHT = 10
+
+        def initialize(screen, state, scrollbar)
+          self.screen = screen
+          self.state = state
+          self.scrollbar = scrollbar
+        end
+
+        def draw
+          log_win.erase
+          log_win.box(0, 0)
+
+          draw_header
+          draw_column_headers
+          draw_rows
+        end
+
+        private
+
+        attr_accessor :screen, :state, :scrollbar
+
+        def draw_header
+          log_win.setpos(0, HEADER_Y_OFFSET)
+
+          if state.left_pane_focused?
+            log_win.attron(color_pair(HEADER_CYAN) | A_BOLD) { log_win.addstr(" Request Logs ") }
+          else
+            log_win.attron(color_pair(DEFAULT_WHITE) | A_DIM) { log_win.addstr(" Request Logs ") }
+          end
+
+          show_filter_in_header if show_filter?
+        end
+
+        def show_filter?
+          state.main_filter.present? || state.main_filter.active?
+        end
+
+        def show_filter_in_header
+          filter_text = "Filter: #{state.main_filter.cursor_display}"
+          filter_x = log_win.maxx - filter_text.length - FILTER_X_MARGIN
+
+          if filter_x > MIN_FILTER_X_POSITION
+            log_win.setpos(0, filter_x)
+            log_win.attron(color_pair(WARNING_YELLOW)) { log_win.addstr(filter_text) }
+          end
+        end
+
+        def draw_column_headers
+          log_win.setpos(COLUMN_HEADER_Y, HEADER_Y_OFFSET)
+          log_win.attron(color_pair(HEADER_CYAN) | A_DIM) do
+            log_win.addstr("METHOD".ljust(METHOD_WIDTH))
+            log_win.addstr("PATH".ljust(screen.panel_width - PATH_MARGIN))
+            log_win.addstr("STATUS".ljust(STATUS_WIDTH))
+            log_win.addstr("TIME")
+          end
+        end
+
+        def draw_rows
+          filtered_requests = state.filtered_requests
+          visible_height = log_win.maxy - 3
+
+          return draw_no_requests_message if filtered_requests.empty?
+
+          state.adjust_auto_scroll(visible_height)
+          state.adjust_scroll_bounds(visible_height)
+
+          visible_height.times do |i|
+            request_index = state.scroll_offset + i
+            break if request_index >= filtered_requests.size
+
+            draw_row(filtered_requests[request_index], request_index, i + 2)
+          end
+
+          # Draw scrollbar if needed
+          if filtered_requests.size > visible_height
+            scrollbar.draw(log_win, visible_height, state.scroll_offset, filtered_requests.size)
+          end
+        end
+
+        def draw_no_requests_message
+          log_win.setpos(log_win.maxy / 2, 3)
+          log_win.attron(A_DIM) { log_win.addstr("No requests found") }
+        end
+
+        def draw_row(request, request_index, y_position)
+          log_win.setpos(y_position, 1)
+
+          if request_index == state.selected
+            log_win.attron(color_pair(10) | A_DIM) do
+              log_win.addstr(" " * (screen.panel_width - 4))
+            end
+            log_win.setpos(y_position, 1)
+          end
+
+          draw_method_badge(request, request_index)
+          draw_path_column(request, request_index)
+          draw_status_column(request, request_index)
+          draw_duration_column(request, request_index)
+        end
+
+        def draw_method_badge(request, request_index)
+          method_color = method_color_for(request.method)
+
+          if request_index == state.selected
+            log_win.attron(color_pair(10) | A_DIM) do
+              log_win.addstr(" #{request.method.ljust(7)} ")
+            end
+          else
+            log_win.attron(color_pair(method_color) | A_BOLD) do
+              log_win.addstr(" #{request.method.ljust(7)} ")
+            end
+          end
+        end
+
+        def draw_path_column(request, request_index)
+          path_width = screen.panel_width - 27
+          path = request.path[0, path_width] || ""
+
+          if request_index == state.selected
+            log_win.attron(color_pair(10) | A_DIM) do
+              log_win.addstr(path.ljust(path_width))
+            end
+          else
+            log_win.addstr(path.ljust(path_width))
+          end
+        end
+
+        def draw_status_column(request, request_index)
+          status_col_start = screen.panel_width - 14
+
+          if request.status
+            status_color = status_color_for(request.status)
+            status_text = request.status.to_s.rjust(3)
+
+            log_win.setpos(log_win.cury, status_col_start)
+            if request_index == state.selected
+              log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(status_text + " ") }
+            else
+              log_win.attron(color_pair(status_color)) { log_win.addstr(status_text + " ") }
+            end
+          end
+        end
+
+        def draw_duration_column(request, request_index)
+          duration_col_start = screen.panel_width - 9
+
+          if request.duration
+            duration_text = "#{request.duration.to_i}ms".ljust(6)
+
+            log_win.setpos(log_win.cury, duration_col_start)
+            if request_index == state.selected
+              log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(duration_text + " ") }
+            else
+              log_win.attron(A_DIM) { log_win.addstr(duration_text + " ") }
+            end
+          end
+        end
+
+        def method_color_for(method)
+          case method
+          when "GET" then 3
+          when "POST" then 4
+          when "PUT" then 5
+          when "DELETE" then 6
+          else 2
+          end
+        end
+
+        def status_color_for(status)
+          case status
+          when 200..299 then 3
+          when 300..399 then 4
+          when 400..599 then 6
+          else 2
+          end
+        end
+
+        def color_pair(n)
+          screen.color_pair(n)
+        end
+
+        def log_win
+          screen.log_win
+        end
+      end
+    end
+  end
+end

data/lib/log_bench/app/renderer/scrollbar.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    module Renderer
+      class Scrollbar
+        include Curses
+
+        def initialize(screen)
+          self.screen = screen
+        end
+
+        def draw(win, height, offset, total)
+          return if total <= height
+
+          scrollbar_height = [(height * height / total), 1].max
+          scrollbar_pos = offset * height / total
+
+          x = win.maxx - 2  # Position scrollbar closer to the border
+          height.times do |i|
+            win.setpos(i + 1, x)
+            if i >= scrollbar_pos && i < scrollbar_pos + scrollbar_height
+              win.attron(color_pair(1)) { win.addstr("█") }  # Solid block for scrollbar thumb
+            end
+          end
+        end
+
+        private
+
+        attr_accessor :screen
+
+        def color_pair(n)
+          screen.color_pair(n)
+        end
+      end
+    end
+  end
+end

data/lib/log_bench/app/screen.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class Screen
+      include Curses
+
+      # Layout constants
+      HEADER_HEIGHT = 5
+      PANEL_BORDER_WIDTH = 3
+      INPUT_TIMEOUT_MS = 200
+
+      # Color pairs
+      HEADER_CYAN = 1
+      DEFAULT_WHITE = 2
+      SUCCESS_GREEN = 3    # GET requests, 200 status
+      WARNING_YELLOW = 4   # POST requests, warnings
+      INFO_BLUE = 5        # PUT requests
+      ERROR_RED = 6        # DELETE requests, errors
+      BRIGHT_WHITE = 7
+      BLACK = 8
+      MAGENTA = 9
+      SELECTION_HIGHLIGHT = 10
+
+      attr_reader :header_win, :log_win, :panel_width, :detail_win
+
+      def setup
+        init_screen
+        setup_colors
+        clear_screen_immediately
+        setup_windows
+      end
+
+      def cleanup
+        close_screen
+      end
+
+      def refresh_all
+        header_win.refresh
+        log_win.refresh
+        detail_win.refresh
+        refresh
+      end
+
+      def height
+        lines
+      end
+
+      def width
+        cols
+      end
+
+      def color_pair(n)
+        Curses.color_pair(n)
+      end
+
+      private
+
+      attr_writer :header_win, :log_win, :panel_width, :detail_win
+
+      def clear_screen_immediately
+        clear
+        refresh
+      end
+
+      def setup_colors
+        start_color
+        cbreak
+        noecho
+        curs_set(0)
+        stdscr.keypad(true)
+        stdscr.timeout = INPUT_TIMEOUT_MS
+
+        # Define color pairs
+        init_pair(HEADER_CYAN, COLOR_CYAN, COLOR_BLACK)      # Header/Cyan
+        init_pair(DEFAULT_WHITE, COLOR_WHITE, COLOR_BLACK)     # Default/White
+        init_pair(SUCCESS_GREEN, COLOR_GREEN, COLOR_BLACK)     # GET/Success/Green
+        init_pair(WARNING_YELLOW, COLOR_YELLOW, COLOR_BLACK)    # POST/Warning/Yellow
+        init_pair(INFO_BLUE, COLOR_BLUE, COLOR_BLACK)      # PUT/Blue
+        init_pair(ERROR_RED, COLOR_RED, COLOR_BLACK)       # DELETE/Error/Red
+        init_pair(BRIGHT_WHITE, COLOR_WHITE, COLOR_BLACK)     # Bold/Bright white
+        init_pair(BLACK, COLOR_BLACK, COLOR_BLACK)     # Black
+        init_pair(MAGENTA, COLOR_MAGENTA, COLOR_BLACK)   # Magenta
+        init_pair(SELECTION_HIGHLIGHT, COLOR_BLACK, COLOR_CYAN)     # Selection highlighting
+      end
+
+      def setup_windows
+        self.panel_width = width / 2 - 2
+
+        self.header_win = Window.new(HEADER_HEIGHT, width, 0, 0)
+        self.log_win = Window.new(height - HEADER_HEIGHT, panel_width, HEADER_HEIGHT, 0)
+        self.detail_win = Window.new(height - HEADER_HEIGHT, width - panel_width - PANEL_BORDER_WIDTH, HEADER_HEIGHT, panel_width + PANEL_BORDER_WIDTH)
+      end
+    end
+  end
+end

data/lib/log_bench/app/sort.rb

@@ -0,0 +1,61 @@
+module LogBench
+  module App
+    class Sort
+      MODES = [:timestamp, :duration, :method, :status].freeze
+
+      def initialize
+        self.mode = :timestamp
+      end
+
+      def cycle
+        current_index = MODES.index(mode)
+        next_index = (current_index + 1) % MODES.length
+        self.mode = MODES[next_index]
+      end
+
+      def display_name
+        case mode
+        when :timestamp then "TIMESTAMP"
+        when :duration then "DURATION"
+        when :method then "METHOD"
+        when :status then "STATUS"
+        end
+      end
+
+      def sort_requests(requests)
+        case mode
+        when :timestamp
+          requests.sort_by { |req| req.timestamp || Time.at(0) }
+        when :duration
+          requests.sort_by { |req| -(req.duration || 0) }  # Descending (slowest first)
+        when :method
+          requests.sort_by { |req| req.method || "" }
+        when :status
+          requests.sort_by { |req| -(req.status || 0) }  # Descending (errors first)
+        else
+          requests
+        end
+      end
+
+      def timestamp?
+        mode == :timestamp
+      end
+
+      def duration?
+        mode == :duration
+      end
+
+      def method?
+        mode == :method
+      end
+
+      def status?
+        mode == :status
+      end
+
+      private
+
+      attr_accessor :mode
+    end
+  end
+end

data/lib/log_bench/app/state.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class State
+      attr_reader :main_filter, :sort, :detail_filter
+      attr_accessor :requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset
+
+      def initialize
+        self.requests = []
+        self.selected = 0
+        self.scroll_offset = 0
+        self.auto_scroll = true
+        self.running = true
+        self.focused_pane = :left
+        self.detail_scroll_offset = 0
+        self.main_filter = Filter.new
+        self.detail_filter = Filter.new
+        self.sort = Sort.new
+      end
+
+      def running?
+        running
+      end
+
+      def stop!
+        self.running = false
+      end
+
+      def toggle_auto_scroll
+        self.auto_scroll = !auto_scroll
+      end
+
+      def clear_filter
+        main_filter.clear
+        self.selected = 0
+        self.scroll_offset = 0
+      end
+
+      def clear_detail_filter
+        detail_filter.clear
+        self.detail_scroll_offset = 0
+      end
+
+      def cycle_sort_mode
+        sort.cycle
+      end
+
+      def switch_to_left_pane
+        self.focused_pane = :left
+      end
+
+      def switch_to_right_pane
+        self.focused_pane = :right
+      end
+
+      def left_pane_focused?
+        focused_pane == :left
+      end
+
+      def right_pane_focused?
+        focused_pane == :right
+      end
+
+      def enter_filter_mode
+        if left_pane_focused?
+          main_filter.enter_mode
+        else
+          detail_filter.enter_mode
+        end
+      end
+
+      def exit_filter_mode
+        main_filter.exit_mode
+        detail_filter.exit_mode
+      end
+
+      def add_to_filter(char)
+        if main_filter.active?
+          main_filter.add_character(char)
+        elsif detail_filter.active?
+          detail_filter.add_character(char)
+        end
+      end
+
+      def backspace_filter
+        if main_filter.active?
+          main_filter.remove_character
+        elsif detail_filter.active?
+          detail_filter.remove_character
+        end
+      end
+
+      def filter_mode
+        main_filter.active?
+      end
+
+      def detail_filter_mode
+        detail_filter.active?
+      end
+
+      def filtered_requests
+        # First apply filter - match exactly like original logtail
+        filtered = if main_filter.present?
+          requests.select do |req|
+            main_filter.matches?(req.path) ||
+              main_filter.matches?(req.method) ||
+              main_filter.matches?(req.controller) ||
+              main_filter.matches?(req.action) ||
+              main_filter.matches?(req.request_id)
+          end
+        else
+          requests
+        end
+
+        # Then apply sorting using Sort domain object
+        sort.sort_requests(filtered)
+      end
+
+      def current_request
+        filtered = filtered_requests
+        return nil if selected >= filtered.size || filtered.empty?
+
+        filtered[selected]
+      end
+
+      def navigate_up
+        if left_pane_focused?
+          self.selected = [selected - 1, 0].max
+          self.auto_scroll = false
+        else
+          self.detail_scroll_offset = [detail_scroll_offset - 1, 0].max
+        end
+      end
+
+      def navigate_down
+        if left_pane_focused?
+          max_index = filtered_requests.size - 1
+          self.selected = [selected + 1, max_index].min
+          self.auto_scroll = false
+        else
+          self.detail_scroll_offset += 1
+        end
+      end
+
+      def adjust_scroll_for_selection(visible_height)
+        return unless left_pane_focused?
+
+        if selected < scroll_offset
+          self.scroll_offset = selected
+        elsif selected >= scroll_offset + visible_height
+          self.scroll_offset = selected - visible_height + 1
+        end
+      end
+
+      def adjust_auto_scroll(visible_height)
+        return unless auto_scroll && !filtered_requests.empty?
+
+        self.selected = filtered_requests.size - 1
+        self.scroll_offset = [selected - visible_height + 1, 0].max
+      end
+
+      def adjust_scroll_bounds(visible_height)
+        filtered = filtered_requests
+        max_offset = [filtered.size - visible_height, 0].max
+        self.scroll_offset = scroll_offset.clamp(0, max_offset)
+      end
+
+      private
+
+      attr_accessor :focused_pane, :running
+      attr_writer :main_filter, :detail_filter, :sort
+    end
+  end
+end

data/lib/log_bench/json_formatter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LogBench
+  # A simple JSON formatter for Rails loggers that creates LogBench-compatible entries
+  # for non-request logging (background jobs, custom events, etc.)
+  #
+  # Usage:
+  #   logger = Logger.new(Rails.root.join('log', 'custom.log'))
+  #   logger.formatter = LogBench::JsonFormatter.new
+  #   logger.info("Background job completed", job_id: 123)
+  #
+  class JsonFormatter < ::Logger::Formatter
+    def call(severity, timestamp, progname, message)
+      log_entry = build_log_entry(severity, timestamp, progname, message)
+      log_entry.to_json + "\n"
+    rescue
+      # Fallback to simple format if JSON generation fails
+      "#{timestamp} [#{severity}] #{progname}: #{message}\n"
+    end
+
+    private
+
+    def build_log_entry(severity, timestamp, progname, message)
+      entry = message_to_hash(message)
+      entry = parse_lograge_message(entry[:message]) if lograge_message?(entry)
+      request_id = current_request_id
+
+      entry.merge!(
+        level: severity,
+        timestamp: timestamp.utc.iso8601(3),
+        time: timestamp.to_f,
+        request_id: request_id,
+        progname: progname
+      ).compact
+    end
+
+    def message_to_hash(message)
+      case message
+      when String
+        {message: message}
+      when Hash
+        message.dup
+      when Exception
+        {
+          message: "#{message.class}: #{message.message}",
+          error_class: message.class.name,
+          error_message: message.message
+        }
+      else
+        {message: message.to_s}
+      end
+    end
+
+    def lograge_message?(entry)
+      # Check if the message field contains lograge JSON
+      return false unless entry[:message].is_a?(String) && entry[:message].start_with?("{")
+
+      # Try to parse and check for lograge fields
+      begin
+        parsed = JSON.parse(entry[:message])
+        parsed.is_a?(Hash) && parsed["method"] && parsed["path"] && parsed["status"]
+      rescue JSON::ParserError
+        false
+      end
+    end
+
+    def parse_lograge_message(message_string)
+      # Parse the lograge JSON string
+      JSON.parse(message_string)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def current_request_id
+      # Try multiple ways to get the current request ID
+      request_id = nil
+
+      if defined?(Current) && Current.respond_to?(:request_id)
+        request_id = Current.request_id
+      elsif defined?(RequestStore) && RequestStore.exist?(:request_id)
+        request_id = RequestStore.read(:request_id)
+      elsif Thread.current[:request_id]
+        request_id = Thread.current[:request_id]
+      end
+
+      # Return nil if no request ID found - let caller decide whether to generate UUID
+      request_id
+    end
+  end
+end