log_bench 0.2.11 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 988ff524c8e07d752d9105bbe0d58008d8209fb0b58d31e0d398cb574ed97b44
-  data.tar.gz: 02c7efab76e2203c1fd77d55ad2c30ecdbb50362eae751e83e7616dd0f4919ca
+  metadata.gz: 2c3190dc4200c7efbd8150e719d16f20cef759621301a498d943958b5b2e805f
+  data.tar.gz: c6dc926d7593d396cc9b4eb298a81009080545fafa56a68031728970c304117d
 SHA512:
-  metadata.gz: 9f84d49ef55a3d88345ce5fee35b645298569743cbd04a210e459bef19a2fa39cf212058db3e11665c3e4e0827db65ebbfbdaa1c4d67439f41a710af63bd67fd
-  data.tar.gz: 659277186d2eac29a7aebd33b15a07237701fb260e0a1890d6f6cd4bdb909a90b9e56fa9b5815dee38b17aaba5c08ec51421cc1013f9e9aef90eaa888c619a5f
+  metadata.gz: 205d48a20a22a4fe91aaf5b31daacc304bee3a95431c38e90db5d393fe7f7c3deeec4e3987594a62caa5f5bed5fb49e512ef454db1440561cb9d7c3a57bcf9c6
+  data.tar.gz: 16e125666602e1eee53f84542ae82cf6da79d18dd3e03f6ee39090e999e441399c7f8ed7f7a041158c412bce38ec61dc76cdc70ee5eafbf36873f36bb050e907

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
@@ -134,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
@@ -148,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/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/screen.rb

@@ -82,22 +82,23 @@ 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
 

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,44 @@ module LogBench
         self.detail_selected_entry = 0
       end
 
+      def clear_requests
+        if cleared_requests
+          cleared_requests[:requests] += requests
+        else
+          self.cleared_requests = {
+            requests: requests,
+            selected: selected,
+            scroll_offset: scroll_offset,
+            detail_scroll_offset: detail_scroll_offset,
+            detail_selected_entry: detail_selected_entry
+          }
+        end
+
+        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 +282,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.11"
+  VERSION = "0.3.1"
 end

metadata

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