log_bench 0.2.10 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfbdd891667f8c0db91b6dc0afd5e7cb4562b941a300d31267dd6cbb973d8257
-  data.tar.gz: 04b3ca23a18b72f7d2798233c53a549788767f92bd40ac7a87214c95a9a1e3ea
+  metadata.gz: be28717377a43d247a6df582b248c5775fd1a0cf99410ff05b4257ac424955c8
+  data.tar.gz: 7c15c4cffc32521a4c8c2afbcee8f3bd0df74ed7799adf5136fcaf2bf25561d4
 SHA512:
-  metadata.gz: 0d9d928b2d0c39c584426f8757855b1d51524e0ef0cc5822b84935ba2c228c3f80e5a22b201a1097f92dad422cfe06b1843ca83173307d59785f8345e27cc520
-  data.tar.gz: 0f7bcf9c8f9ceaa040ccb7e9b9b7b2d9a7f570cb1b7d03d2be4c5390dfb26137cc3d6cc358fea903d55c7fd89a2315276a725c8112e80e909d2352c0d75db489
+  metadata.gz: e09e1a5ba15a01948ba8cd459c9cecb335bac3ffefcbf921ce464f30bd6f6a2ae68db80b2529d2e41db8f141c5f58961aed9af6b926b5d35999c7370c7bae370
+  data.tar.gz: 98513f5775754f387dfe7baf89af16861841f734412f4ccd30d9adea40fbad67b92899ca240af7efed048aa6bdf917da20dd25c71a21ad72840f9c540a4cfacb

data/README.md

@@ -118,6 +118,8 @@ log_bench log/development.log
 - **Auto-scroll**: `a` to toggle auto-scroll mode
 - **Copy**: `y` to copy the selected item to clipboard (request details or SQL query)
 - **Text selection**: `t` to toggle text selection mode (enables mouse text selection)
+- **Clear requests**: `Ctrl+L` to clear all requests from memory (preserves current position)
+- **Undo clear**: `Ctrl+R` to restore previously cleared requests + any new requests (restores exact position)
 - **Quit**: `q` to exit
 
 ### Filtering

data/lib/log_bench/app/clipboard.rb

@@ -12,6 +12,9 @@ module LogBench
         if system("which pbcopy > /dev/null 2>&1")
           # macOS
           IO.popen("pbcopy", "w") { |io| io.write(text) }
+        elsif system("which wl-copy > /dev/null 2>&1")
+          # Linux with wl-copy (wayland)
+          IO.popen("wl-copy", "w") { |io| io.write(text) }
         elsif system("which xclip > /dev/null 2>&1")
           # Linux with xclip
           IO.popen("xclip -selection clipboard", "w") { |io| io.write(text) }

data/lib/log_bench/app/copy_handler.rb

@@ -146,7 +146,8 @@ module LogBench
       def sql_query?(text)
         # Check for common SQL keywords that indicate this is a SQL query
         sql_keywords = %w[SELECT INSERT UPDATE DELETE TRANSACTION BEGIN COMMIT ROLLBACK SAVEPOINT]
-        sql_keywords.any? { |keyword| text.upcase.include?(keyword) }
+        pattern = /\b(#{sql_keywords.join("|")})\b/i
+        text.match?(pattern)
       end
     end
   end

data/lib/log_bench/app/input_handler.rb

@@ -12,6 +12,8 @@ module LogBench
       CTRL_D = 4          # Half page down
       CTRL_U = 21         # Half page up
       CTRL_C = 3          # Quit
+      CTRL_L = 12         # Clear requests
+      CTRL_R = 18         # Undo clear requests (restore)
       ESC = 27            # Escape
 
       # UI constants
@@ -34,7 +36,9 @@ module LogBench
           return
         end
 
-        if ch == KEY_MOUSE
+        if ch == KEY_RESIZE
+          handle_resize
+        elsif ch == KEY_MOUSE
           mouse_handler.handle_mouse_input
         elsif filter_mode_active?
           handle_filter_input(ch)
@@ -43,6 +47,11 @@ module LogBench
         end
       end
 
+      def handle_resize
+        screen.handle_resize
+        renderer&.invalidate_caches
+      end
+
       private
 
       attr_accessor :state, :screen, :renderer, :mouse_handler, :copy_handler
@@ -127,11 +136,7 @@ module LogBench
         when "f", "F", "/"
           state.enter_filter_mode
         when "c", "C"
-          if state.left_pane_focused?
-            state.clear_filter
-          else
-            state.clear_detail_filter
-          end
+          state.clear_filter
         when "s", "S"
           state.cycle_sort_mode
         when "q", "Q", CTRL_C
@@ -141,6 +146,10 @@ module LogBench
           screen.turn_text_selection_mode(state.text_selection_mode?)
         when "y", "Y"
           copy_handler.copy_to_clipboard
+        when CTRL_L
+          state.clear_requests
+        when CTRL_R
+          state.undo_clear_requests
         when ESC
           handle_escape
         end

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

@@ -41,6 +41,11 @@ module LogBench
           cached_lines
         end
 
+        def invalidate_cache
+          self.cached_lines = nil
+          self.cache_key = nil
+        end
+
         private
 
         attr_accessor :screen, :state, :scrollbar, :ansi_renderer, :cached_lines, :cache_key

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

@@ -84,7 +84,9 @@ module LogBench
 
           header_win.setpos(3, 2)
           header_win.attron(A_DIM) do
-            header_win.addstr("←→/hl:Switch Pane | ↑↓/jk/Click:Navigate | g/G:Top/End | y:Copy highlighted")
+            header_win.addstr("←→/hl:Pane | ↑↓/jk:Navigate | g/G:Top/End | y:Copy highlighted | Ctrl+L:Clear | Ctrl+R:Restore(")
+            header_win.attron(color_pair(3)) { header_win.addstr(state.can_undo_clear? ? "READY" : "N/A") }
+            header_win.addstr(")")
           end
         end
 

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

@@ -34,6 +34,10 @@ module LogBench
           details.get_cached_detail_lines(request)
         end
 
+        def invalidate_caches
+          details.invalidate_cache
+        end
+
         private
 
         attr_accessor :screen, :state, :header, :scrollbar, :request_list, :ansi_renderer, :details, :update_modal

data/lib/log_bench/app/screen.rb

@@ -33,6 +33,7 @@ module LogBench
       end
 
       def cleanup
+        cleanup_windows
         close_screen
       end
 
@@ -59,6 +60,17 @@ module LogBench
         enabled ? mousemask(0) : mousemask(BUTTON1_CLICKED)
       end
 
+      def handle_resize
+        # Update terminal dimensions
+        resizeterm(0, 0)
+        clear
+        refresh
+
+        # Recreate windows with new dimensions
+        cleanup_windows
+        setup_windows
+      end
+
       private
 
       attr_writer :header_win, :log_win, :panel_width, :detail_win
@@ -70,25 +82,32 @@ module LogBench
 
       def setup_colors
         start_color
+        use_default_colors
         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
+        # Define color pairs with transparent background (-1)
+        init_pair(HEADER_CYAN, COLOR_CYAN, -1)      # Header/Cyan
+        init_pair(DEFAULT_WHITE, COLOR_WHITE, -1)     # Default/White
+        init_pair(SUCCESS_GREEN, COLOR_GREEN, -1)     # GET/Success/Green
+        init_pair(WARNING_YELLOW, COLOR_YELLOW, -1)    # POST/Warning/Yellow
+        init_pair(INFO_BLUE, COLOR_BLUE, -1)      # PUT/Blue
+        init_pair(ERROR_RED, COLOR_RED, -1)       # DELETE/Error/Red
+        init_pair(BRIGHT_WHITE, COLOR_WHITE, -1)     # Bold/Bright white
+        init_pair(BLACK, COLOR_BLACK, -1)     # Black
+        init_pair(MAGENTA, COLOR_MAGENTA, -1)   # Magenta
         init_pair(SELECTION_HIGHLIGHT, COLOR_BLACK, COLOR_CYAN)     # Selection highlighting
       end
 
+      def cleanup_windows
+        header_win&.close
+        log_win&.close
+        detail_win&.close
+      end
+
       def setup_windows
         self.panel_width = width / 2 - 2
 

data/lib/log_bench/app/state.rb

@@ -3,7 +3,7 @@
 module LogBench
   module App
     class State
-      attr_reader :main_filter, :sort, :detail_filter
+      attr_reader :main_filter, :sort, :detail_filter, :cleared_requests
       attr_accessor :requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset, :detail_selected_entry, :text_selection_mode, :update_available, :update_version
 
       def initialize
@@ -21,6 +21,7 @@ module LogBench
         self.sort = Sort.new
         self.update_available = false
         self.update_version = nil
+        self.cleared_requests = nil
       end
 
       def running?
@@ -58,6 +59,14 @@ module LogBench
       end
 
       def clear_filter
+        if left_pane_focused?
+          clear_requests_filter
+        else
+          clear_detail_filter
+        end
+      end
+
+      def clear_requests_filter
         main_filter.clear
         self.selected = 0
         self.scroll_offset = 0
@@ -69,6 +78,41 @@ module LogBench
         self.detail_selected_entry = 0
       end
 
+      def clear_requests
+        # Store current state for undo functionality
+        self.cleared_requests = {
+          requests: requests.dup,
+          selected: selected,
+          scroll_offset: scroll_offset,
+          detail_scroll_offset: detail_scroll_offset,
+          detail_selected_entry: detail_selected_entry
+        }
+
+        self.requests = []
+        self.selected = 0
+        self.scroll_offset = 0
+        self.detail_scroll_offset = 0
+        self.detail_selected_entry = 0
+      end
+
+      def undo_clear_requests
+        return unless cleared_requests
+
+        # Append any new requests that came in after the clear to the restored requests
+        restored_requests = cleared_requests[:requests] + requests
+
+        self.requests = restored_requests
+        self.selected = cleared_requests[:selected]
+        self.scroll_offset = cleared_requests[:scroll_offset]
+        self.detail_scroll_offset = cleared_requests[:detail_scroll_offset]
+        self.detail_selected_entry = cleared_requests[:detail_selected_entry]
+        self.cleared_requests = nil
+      end
+
+      def can_undo_clear?
+        !cleared_requests.nil?
+      end
+
       def cycle_sort_mode
         sort.cycle
       end
@@ -235,7 +279,7 @@ module LogBench
       private
 
       attr_accessor :focused_pane, :running
-      attr_writer :main_filter, :detail_filter, :sort
+      attr_writer :main_filter, :detail_filter, :sort, :cleared_requests
     end
   end
 end

data/lib/log_bench/log/entry.rb

@@ -5,22 +5,12 @@ module LogBench
     class Entry
       attr_reader :type, :raw_line, :request_id, :timestamp, :content, :timing
 
-      def initialize(raw_line)
-        self.raw_line = raw_line.strip
-        self.timestamp = Time.now
-        self.type = :unknown
-        parse!
-      end
-
-      def self.build(raw_line)
-        new(raw_line) if parseable?(raw_line)
-      end
-
-      def self.parseable?(line)
-        data = JSON.parse(line.strip)
-        data.is_a?(Hash)
-      rescue JSON::ParserError
-        false
+      def initialize(json_data)
+        self.json_data = json_data
+        self.timestamp = parse_timestamp(json_data["timestamp"])
+        self.request_id = json_data["request_id"]
+        self.content = json_data["message"] || ""
+        self.type = :other
       end
 
       def http_request?
@@ -33,60 +23,8 @@ module LogBench
 
       private
 
-      attr_writer :type, :raw_line, :timestamp, :request_id, :content, :timing
-
-      def parse!
-        parse_json
-      end
-
-      def parse_json
-        data = JSON.parse(raw_line)
-        return false unless data.is_a?(Hash)
-
-        # extract_from_json returns false if log should be discarded
-        extract_from_json(data)
-      rescue JSON::ParserError
-        false
-      end
-
-      def extract_from_json(data)
-        # Discard logs without request_id - they can't be correlated
-        return false unless data["request_id"]
-
-        self.timestamp = parse_timestamp(data["timestamp"])
-        self.request_id = data["request_id"]
-        self.content = data["message"] || ""
-        self.type = determine_json_type(data)
-        true
-      end
-
-      def determine_json_type(data)
-        return :http_request if lograge_request?(data)
-        return :cache if cache_message?(data)
-        return :sql if sql_message?(data)
-        return :sql_call_line if call_stack_message?(data)
-
-        :other
-      end
-
-      def lograge_request?(data)
-        data["method"] && data["path"] && data["status"]
-      end
-
-      def sql_message?(data)
-        message = data["message"] || ""
-        %w[SELECT INSERT UPDATE DELETE TRANSACTION BEGIN COMMIT ROLLBACK SAVEPOINT].any? { |op| message.include?(op) }
-      end
-
-      def cache_message?(data)
-        message = data["message"] || ""
-        message.include?("CACHE")
-      end
-
-      def call_stack_message?(data)
-        message = data["message"] || ""
-        message.include?("↳")
-      end
+      attr_writer :type, :timestamp, :request_id, :content, :timing
+      attr_accessor :json_data
 
       def parse_timestamp(timestamp_str)
         return Time.now unless timestamp_str

data/lib/log_bench/log/file.rb

@@ -3,7 +3,8 @@
 module LogBench
   module Log
     class File
-      attr_reader :path, :last_position
+      INACTIVE_SLEEP_TIME = 0.5
+      ACTIVE_SLEEP_TIME = 0.01
 
       def initialize(path)
         self.path = find_log_file(path)
@@ -15,42 +16,36 @@ module LogBench
         collection.requests
       end
 
-      def entries
-        collection.entries
-      end
+      def watch
+        loop do
+          new_lines = read_new_lines
 
-      def collection
-        @collection ||= Collection.new(lines)
-      end
+          if new_lines.empty?
+            sleep INACTIVE_SLEEP_TIME
+            next
+          end
 
-      def lines
-        @lines ||= read_lines
-      end
+          new_collection = Collection.new(new_lines)
+          yield new_collection unless new_collection.empty?
 
-      def reload!
-        self.lines = nil
-        self.collection = nil
-        self.last_position = 0
+          sleep ACTIVE_SLEEP_TIME
+        end
       end
 
-      def tail(max_lines = 1000)
-        all_lines = read_lines
-        recent_lines = all_lines.last(max_lines)
-        Collection.new(recent_lines)
+      def mark_as_read!
+        self.last_position = size
       end
 
-      def watch(&block)
-        return enum_for(:watch) unless block_given?
+      private
 
-        loop do
-          new_lines = read_new_lines
-          next if new_lines.empty?
+      attr_accessor :path, :last_position
 
-          new_collection = Collection.new(new_lines)
-          yield new_collection unless new_collection.empty?
+      def collection
+        @collection ||= Collection.new(lines)
+      end
 
-          sleep 0.5
-        end
+      def lines
+        @lines ||= read_lines
       end
 
       def size
@@ -61,18 +56,6 @@ module LogBench
         ::File.exist?(path)
       end
 
-      def mtime
-        ::File.mtime(path)
-      end
-
-      def mark_as_read!
-        self.last_position = size
-      end
-
-      private
-
-      attr_writer :path, :last_position
-
       def read_lines
         return [] unless exist?
 

data/lib/log_bench/log/parser.rb

@@ -4,10 +4,13 @@ module LogBench
   module Log
     class Parser
       def self.parse_line(raw_line)
-        return unless Entry.parseable?(raw_line)
+        clean_line = raw_line.encode("UTF-8", invalid: :replace, undef: :replace, replace: "").strip
+        data = JSON.parse(clean_line)
+        return unless data.is_a?(Hash)
 
-        entry = Entry.new(raw_line)
-        build_specific_entry(entry)
+        build_specific_entry(data)
+      rescue JSON::ParserError
+        nil
       end
 
       def self.parse_lines(lines)
@@ -19,16 +22,18 @@ module LogBench
         build_requests_from_groups(grouped)
       end
 
-      def self.build_specific_entry(entry)
-        case entry.type
+      def self.build_specific_entry(data)
+        case determine_json_type(data)
         when :http_request
-          Request.build(entry.raw_line)
-        when :sql, :cache
-          QueryEntry.build(entry.raw_line)
+          Request.new(data)
+        when :sql
+          QueryEntry.new(data, cached: false)
+        when :cache
+          QueryEntry.new(data, cached: true)
         when :sql_call_line
-          CallLineEntry.build(entry.raw_line)
+          CallLineEntry.new(data)
         else
-          entry
+          Entry.new(data)
         end
       end
 
@@ -57,6 +62,34 @@ module LogBench
       def self.find_related_logs(entries)
         entries.reject { |entry| entry.is_a?(Request) }
       end
+
+      def self.determine_json_type(data)
+        return :http_request if lograge_request?(data)
+        return :cache if cache_message?(data)
+        return :sql if sql_message?(data)
+        return :sql_call_line if call_stack_message?(data)
+
+        :other
+      end
+
+      def self.lograge_request?(data)
+        data["method"] && data["path"] && data["status"]
+      end
+
+      def self.sql_message?(data)
+        message = data["message"] || ""
+        %w[SELECT INSERT UPDATE DELETE TRANSACTION BEGIN COMMIT ROLLBACK SAVEPOINT].any? { |op| message.include?(op) }
+      end
+
+      def self.cache_message?(data)
+        message = data["message"] || ""
+        message.include?("CACHE")
+      end
+
+      def self.call_stack_message?(data)
+        message = data["message"] || ""
+        message.include?("↳")
+      end
     end
   end
 end

data/lib/log_bench/log/query_entry.rb

@@ -14,21 +14,11 @@ module LogBench
       SAVEPOINT = "SAVEPOINT"
       SQL_OPERATIONS = [SELECT, INSERT, UPDATE, DELETE, TRANSACTION, BEGIN_TRANSACTION, COMMIT, ROLLBACK, SAVEPOINT].freeze
 
-      def initialize(raw_line, cached: false)
-        super(raw_line)
+      def initialize(json_data, cached: false)
+        super(json_data)
         self.type = cached ? :cache : :sql
-        @cached = cached
-      end
-
-      def self.build(raw_line)
-        return unless parseable?(raw_line)
-
-        entry = Entry.new(raw_line)
-        return unless [:sql, :cache].include?(entry.type)
-
-        # Create QueryEntry for both SQL and CACHE entries
-        cached = entry.type == :cache
-        new(raw_line, cached: cached)
+        self.timing = extract_timing
+        self.operation = extract_operation
       end
 
       def duration_ms
@@ -72,7 +62,7 @@ module LogBench
       end
 
       def cached?
-        @cached
+        type == :cache
       end
 
       def hit?
@@ -81,24 +71,7 @@ module LogBench
 
       private
 
-      attr_accessor :operation
-
-      def extract_from_json(data)
-        # Call parent method which checks for request_id
-        return false unless super
-
-        message = data["message"] || ""
-        return false unless sql_message?(data) || cache_message?(data)
-
-        self.content = message.strip
-        extract_timing_and_operation
-        true
-      end
-
-      def extract_timing_and_operation
-        self.timing = extract_timing
-        self.operation = extract_operation
-      end
+      attr_accessor :operation, :cached
 
       def extract_timing
         match = clean_content.match(/\(([0-9.]+ms)\)/)

data/lib/log_bench/log/request.rb

@@ -5,18 +5,17 @@ module LogBench
     class Request < Entry
       attr_reader :method, :path, :status, :duration, :controller, :action, :params, :related_logs
 
-      def initialize(raw_line)
+      def initialize(json_data)
         super
+        self.type = :http_request
         self.related_logs = []
-      end
-
-      def self.build(raw_line)
-        return unless parseable?(raw_line)
-
-        entry = Entry.new(raw_line)
-        return unless entry.http_request?
-
-        new(raw_line)
+        self.method = json_data["method"]
+        self.path = json_data["path"]
+        self.status = json_data["status"]
+        self.duration = json_data["duration"]
+        self.controller = json_data["controller"]
+        self.action = json_data["action"]
+        self.params = parse_params(json_data["params"])
       end
 
       def add_related_log(log_entry)
@@ -79,20 +78,6 @@ module LogBench
         @cached_query_count = nil
       end
 
-      def extract_from_json(data)
-        return false unless super
-
-        self.method = data["method"]
-        self.path = data["path"]
-        self.status = data["status"]
-        self.duration = data["duration"]
-        self.controller = data["controller"]
-        self.action = data["action"]
-        self.request_id = data["request_id"]
-        self.params = parse_params(data["params"])
-        true
-      end
-
       def parse_params(params_data)
         return nil unless params_data
 

data/lib/log_bench/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LogBench
-  VERSION = "0.2.10"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: log_bench
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
 platform: ruby
 authors:
 - Benjamín Silva
 bindir: exe
 cert_chain: []
-date: 2025-08-29 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk