log_bench 0.2.6 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7dee0d20491347e20b631992dd88b3859ddc373dd4962306fa8d36a1955f119
-  data.tar.gz: 2923c231a8afaa145b42d485319c997c03cd4765bc13c0e224cb3e8a6955bdaf
+  metadata.gz: a7bf1724c565d5848f6867b14ec19675a50594b369cb3d7729d117b310f4d399
+  data.tar.gz: cc2c21dc13a0981b11c92933ecbe967a6cf98b7a7ff21e27d322e156932e42a0
 SHA512:
-  metadata.gz: 70fb36f5e8bbf5c349e40ad145971e90526c1f37cdfe08f3e93a7e539ef6a99cbfe90be6ddb91e39f9eb6d77009b9fb91b6b4cb4facc5a4d7c53a7dbb20dc1be
-  data.tar.gz: 7474a672815d2403fcc9e4fdf7e0c962f763476bda2662ffedbd2332c9e043c5eb37204e30d65a9a317696aad9eb3f33a0547a6419a7f05a00afd6b9570ed539
+  metadata.gz: 61423f51d81a4c5b30d963fb3da1ba4739aa0420b7b388e6b5fb01952cbb7c60eba2b3091ef520fefb81ab67310611d175d45bacb9d00f63199911cf3ab4cc44
+  data.tar.gz: 5a4c48ed233d247ca70d1aaa36f9eb676b598282dfb573055a3200d9002f7978f31c46a44f57e0e4270308a296523862f4670360ab8df3eabb530ac5f7365bcd

data/README.md

@@ -116,6 +116,8 @@ log_bench log/development.log
 - **Clear filter**: `c` to clear an active filter (press `escape` or `enter` before pressing `c` to clear)
 - **Sorting**: `s` to cycle through sort options (timestamp, duration, status)
 - **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)
 - **Quit**: `q` to exit
 
 ### Filtering
@@ -142,6 +144,24 @@ Examples:
 In the right pane you can filter related log lines by text content to find specific SQL queries or anything else
 you want to find in the logs.
 
+### Copying Content
+
+LogBench provides multiple ways to copy content:
+
+**Smart Copy with `y` key:**
+- **Left pane**: Copies complete request details (method, path, status, duration, etc.)
+- **Right pane**: Copies the selected SQL query with its call source location
+
+**Text Selection Mode:**
+- Press `t` to toggle text selection mode
+- When enabled, you can use your mouse to select and copy text normally
+- When disabled, mouse clicks navigate the interface
+
+**Clipboard Support:**
+- **macOS**: Uses `pbcopy` (built-in)
+- **Linux**: Uses `xclip` or `xsel` (install with your package manager)
+- **Fallback**: Saves to `/tmp/logbench_copy.txt` if no clipboard tool available
+
 
 ## Log Format
 

data/lib/log_bench/app/clipboard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class Clipboard
+      def self.copy(text)
+        new.copy(text)
+      end
+
+      def copy(text)
+        # Try different clipboard commands based on the platform
+        if system("which pbcopy > /dev/null 2>&1")
+          # macOS
+          IO.popen("pbcopy", "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) }
+        elsif system("which xsel > /dev/null 2>&1")
+          # Linux with xsel
+          IO.popen("xsel --clipboard --input", "w") { |io| io.write(text) }
+        else
+          # Fallback: write to a temporary file
+          temp_file = "/tmp/logbench_copy.txt"
+          File.write(temp_file, text)
+        end
+      rescue
+        # Silently fail - we don't want to crash the TUI
+      end
+    end
+  end
+end

data/lib/log_bench/app/copy_handler.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class CopyHandler
+      def initialize(state, renderer)
+        self.state = state
+        self.renderer = renderer
+      end
+
+      def copy_to_clipboard
+        if state.left_pane_focused?
+          copy_selected_request
+        else
+          copy_selected_detail_entry
+        end
+      end
+
+      private
+
+      attr_accessor :state, :renderer
+
+      def copy_selected_request
+        request = state.current_request
+        return unless request
+
+        # Create a comprehensive text representation of the request
+        content = []
+        content << "```"
+        content << "#{request.method} #{request.path} #{request.status}"
+        content << "Duration: #{request.duration}ms" if request.duration
+        content << "Controller: #{request.controller}" if request.controller
+        content << "Action: #{request.action}" if request.action
+        content << "Request ID: #{request.request_id}" if request.request_id
+        content << "Timestamp: #{request.timestamp}" if request.timestamp
+        content << "Params: #{request.params}" if request.params && !request.params.empty?
+
+        # Add query summary if there are related logs
+        if request.related_logs && !request.related_logs.empty?
+          query_summary = QuerySummary.new(request).build_text_summary
+          content << ""
+          content << query_summary
+        end
+
+        content << "```"
+
+        Clipboard.copy(content.join("\n"))
+      end
+
+      def copy_selected_detail_entry
+        request = state.current_request
+        return unless request
+
+        # Get the detail lines for the current request
+        lines = renderer&.get_cached_detail_lines(request)
+        return unless lines
+
+        # Find all unique entry IDs, excluding separator lines
+        entry_ids = lines.reject { |line| line[:separator] }.map { |line| line[:entry_id] }.compact.uniq
+        return if state.detail_selected_entry >= entry_ids.size
+
+        # Get the selected entry ID
+        selected_entry_id = entry_ids[state.detail_selected_entry]
+        return unless selected_entry_id
+
+        # Find all lines belonging to the selected entry
+        selected_lines = lines.select { |line| line[:entry_id] == selected_entry_id }
+
+        # Extract the text content, removing ANSI codes and padding
+        content = selected_lines.map do |line|
+          text = line[:text] || ""
+          # Remove ANSI escape codes and trim padding
+          text.gsub(/\e\[[0-9;]*m/, "").strip
+        end.reject(&:empty?)
+
+        # Check if this is a SQL query by looking for SQL keywords in the content
+        content_text = content.join(" ")
+        is_sql_query = sql_query?(content_text)
+
+        if is_sql_query
+          Clipboard.copy("```sql\n#{content.join("\n")}\n```")
+        else
+          Clipboard.copy(content.join("\n"))
+        end
+      end
+
+      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) }
+      end
+    end
+  end
+end

data/lib/log_bench/app/input_handler.rb

@@ -22,6 +22,7 @@ module LogBench
         self.screen = screen
         self.renderer = renderer
         self.mouse_handler = MouseHandler.new(state, screen)
+        self.copy_handler = CopyHandler.new(state, renderer)
       end
 
       def handle_input
@@ -44,7 +45,7 @@ module LogBench
 
       private
 
-      attr_accessor :state, :screen, :renderer, :mouse_handler
+      attr_accessor :state, :screen, :renderer, :mouse_handler, :copy_handler
 
       def filter_mode_active?
         state.filter_mode || state.detail_filter_mode
@@ -138,6 +139,8 @@ module LogBench
         when "t", "T"
           state.toggle_text_selection_mode
           screen.turn_text_selection_mode(state.text_selection_mode?)
+        when "y", "Y"
+          copy_handler.copy_to_clipboard
         when ESC
           handle_escape
         end
@@ -152,16 +155,30 @@ module LogBench
       end
 
       def handle_up_navigation
+        old_selected = state.selected if state.left_pane_focused?
         state.navigate_up
-        state.adjust_scroll_for_selection(visible_height) if state.left_pane_focused?
+        if state.left_pane_focused?
+          state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
+        end
       end
 
       def handle_down_navigation
         if state.left_pane_focused?
+          old_selected = state.selected
           max_index = state.filtered_requests.size - 1
           state.selected = [state.selected + 1, max_index].min
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
           state.navigate_down
         end
@@ -169,69 +186,109 @@ module LogBench
 
       def handle_page_down
         if state.left_pane_focused?
+          old_selected = state.selected
           page_size = visible_height
           max_index = state.filtered_requests.size - 1
           state.selected = [state.selected + page_size, max_index].min
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          state.detail_scroll_offset += visible_height
+          page_size = visible_height
+          state.detail_selected_entry += page_size
         end
       end
 
       def handle_page_up
         if state.left_pane_focused?
+          old_selected = state.selected
           page_size = visible_height
           state.selected = [state.selected - page_size, 0].max
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          state.detail_scroll_offset = [state.detail_scroll_offset - visible_height, 0].max
+          page_size = visible_height
+          state.detail_selected_entry = [state.detail_selected_entry - page_size, 0].max
         end
       end
 
       def handle_half_page_down
         if state.left_pane_focused?
+          old_selected = state.selected
           half_page = visible_height / 2
           max_index = state.filtered_requests.size - 1
           state.selected = [state.selected + half_page, max_index].min
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          state.detail_scroll_offset += visible_height / 2
+          half_page = visible_height / 2
+          state.detail_selected_entry += half_page
         end
       end
 
       def handle_half_page_up
         if state.left_pane_focused?
+          old_selected = state.selected
           half_page = visible_height / 2
           state.selected = [state.selected - half_page, 0].max
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          state.detail_scroll_offset = [state.detail_scroll_offset - visible_height / 2, 0].max
+          half_page = visible_height / 2
+          state.detail_selected_entry = [state.detail_selected_entry - half_page, 0].max
         end
       end
 
       def handle_go_to_top
         if state.left_pane_focused?
+          old_selected = state.selected
           state.selected = 0
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          state.detail_scroll_offset = 0
+          state.detail_selected_entry = 0
         end
       end
 
       def handle_go_to_bottom
         if state.left_pane_focused?
+          old_selected = state.selected
           max_index = state.filtered_requests.size - 1
           state.selected = [max_index, 0].max
           state.auto_scroll = false
           state.adjust_scroll_for_selection(visible_height)
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         else
-          # Calculate max scroll for detail pane
-          state.detail_scroll_offset = 999  # Will be adjusted by renderer
+          # Set to a high value, will be adjusted by bounds checking
+          state.detail_selected_entry = 999999
         end
       end
 

data/lib/log_bench/app/mouse_handler.rb

@@ -40,9 +40,15 @@ module LogBench
           request_index = click_to_request_index(y)
           return unless request_index
 
+          old_selected = state.selected
           max_index = state.filtered_requests.size - 1
           state.selected = [request_index, max_index].min
           state.auto_scroll = false
+
+          # Reset detail selection when switching requests
+          if old_selected != state.selected
+            state.reset_detail_selection
+          end
         elsif click_in_right_pane?(x, y)
           # Switch to right pane
           state.switch_to_right_pane unless state.right_pane_focused?

data/lib/log_bench/app/query_summary.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class QuerySummary
+      def initialize(request)
+        self.request = request
+      end
+
+      def build_stats
+        # Use memoized methods from request object for better performance
+        stats = {
+          total_queries: request.query_count,
+          total_time: request.total_query_time,
+          cached_queries: request.cached_query_count,
+          select: 0,
+          insert: 0,
+          update: 0,
+          delete: 0,
+          transaction: 0
+        }
+
+        # Categorize by operation type for breakdown
+        request.related_logs.each do |log|
+          next unless [:sql, :cache].include?(log.type)
+
+          categorize_sql_operation(log, stats)
+        end
+
+        stats
+      end
+
+      def build_text_summary
+        query_stats = build_stats
+
+        summary_lines = []
+        summary_lines << "Query Summary:"
+
+        if query_stats[:total_queries] > 0
+          summary_lines << build_summary_line(query_stats)
+
+          breakdown_line = build_breakdown_line(query_stats)
+          summary_lines << breakdown_line unless breakdown_line.empty?
+        end
+
+        summary_lines.join("\n")
+      end
+
+      def build_summary_line(query_stats = nil)
+        query_stats ||= build_stats
+
+        summary_parts = ["#{query_stats[:total_queries]} queries"]
+
+        if query_stats[:total_time] > 0
+          time_part = "#{query_stats[:total_time].round(1)}ms total"
+          time_part += ", #{query_stats[:cached_queries]} cached" if query_stats[:cached_queries] > 0
+          summary_parts << "(#{time_part})"
+        elsif query_stats[:cached_queries] > 0
+          summary_parts << "(#{query_stats[:cached_queries]} cached)"
+        end
+
+        summary_parts.join(" ")
+      end
+
+      def build_breakdown_line(query_stats = nil)
+        query_stats ||= build_stats
+
+        breakdown_parts = [
+          ("#{query_stats[:select]} SELECT" if query_stats[:select] > 0),
+          ("#{query_stats[:insert]} INSERT" if query_stats[:insert] > 0),
+          ("#{query_stats[:update]} UPDATE" if query_stats[:update] > 0),
+          ("#{query_stats[:delete]} DELETE" if query_stats[:delete] > 0),
+          ("#{query_stats[:transaction]} TRANSACTION" if query_stats[:transaction] > 0)
+        ].compact
+
+        breakdown_parts.join(", ")
+      end
+
+      private
+
+      attr_accessor :request
+
+      def categorize_sql_operation(log, stats)
+        # Use unified QueryEntry for both SQL and CACHE entries
+        return unless log.is_a?(LogBench::Log::QueryEntry)
+
+        if log.select?
+          stats[:select] += 1
+        elsif log.insert?
+          stats[:insert] += 1
+        elsif log.update?
+          stats[:update] += 1
+        elsif log.delete?
+          stats[:delete] += 1
+        elsif log.transaction? || log.begin? || log.commit? || log.rollback? || log.savepoint?
+          stats[:transaction] += 1
+        end
+      end
+    end
+  end
+end

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

@@ -39,73 +39,60 @@ module LogBench
             [text]
           else
             chunks = []
-            remaining = text
-            active_colors = []
 
-            # Extract initial color state
-            text.scan(/\e\[[0-9;]*m/) do |ansi_code|
-              if /\e\[0m/.match?(ansi_code)
-                active_colors.clear
-              else
-                active_colors << ansi_code
-              end
-            end
+            # Parse the text to extract segments with their colors
+            segments = parse_ansi_segments(text)
 
-            while remaining.length > 0
-              clean_remaining = remaining.gsub(/\e\[[0-9;]*m/, "")
+            current_chunk = ""
+            current_chunk_length = 0
+            active_color_state = ""
 
-              if clean_remaining.length <= max_width
-                # Last chunk
-                chunks << if active_colors.any? && !remaining.start_with?(*active_colors)
-                  active_colors.join("") + remaining
+            segments.each do |segment|
+              if segment[:type] == :ansi
+                # Track color state
+                active_color_state = if segment[:text] == "\e[0m"
+                  ""
                 else
-                  remaining
+                  segment[:text]
                 end
-                break
+                current_chunk += segment[:text]
               else
-                # Find break point and preserve color state
-                break_point = max_width
-                original_pos = 0
-                clean_pos = 0
-                chunk_colors = active_colors.dup
-
-                remaining.each_char.with_index do |char, idx|
-                  if /^\e\[[0-9;]*m/.match?(remaining[idx..])
-                    # Found ANSI sequence
-                    ansi_match = remaining[idx..].match(/^(\e\[[0-9;]*m)/)
-                    ansi_code = ansi_match[1]
-
-                    if /\e\[0m/.match?(ansi_code)
-                      chunk_colors.clear
-                      active_colors.clear
-                    else
-                      chunk_colors << ansi_code unless chunk_colors.include?(ansi_code)
-                      active_colors << ansi_code unless active_colors.include?(ansi_code)
-                    end
+                # Text segment - check if it fits
+                text_content = segment[:text]
 
-                    original_pos += ansi_code.length
-                    idx + ansi_code.length - 1
-                  else
-                    clean_pos += 1
-                    original_pos += 1
+                while text_content.length > 0
+                  remaining_space = max_width - current_chunk_length
 
-                    if clean_pos >= break_point
-                      break
+                  if text_content.length <= remaining_space
+                    # Entire text fits in current chunk
+                    current_chunk += text_content
+                    current_chunk_length += text_content.length
+                    break
+                  else
+                    # Need to split the text
+                    if remaining_space > 0
+                      # Take what fits in current chunk
+                      chunk_part = text_content[0...remaining_space]
+                      current_chunk += chunk_part
+                      text_content = text_content[remaining_space..]
                     end
-                  end
-                end
 
-                chunk_text = remaining[0...original_pos]
-                chunks << if active_colors.any? && !chunk_text.start_with?(*active_colors)
-                  active_colors.join("") + chunk_text
-                else
-                  chunk_text
-                end
+                    # Finish current chunk
+                    chunks << current_chunk
 
-                remaining = remaining[original_pos..]
+                    # Start new chunk with color state
+                    current_chunk = active_color_state
+                    current_chunk_length = 0
+                  end
+                end
               end
             end
 
+            # Add final chunk if it has content
+            if current_chunk.length > 0
+              chunks << current_chunk
+            end
+
             chunks
           end
         end
@@ -143,6 +130,40 @@ module LogBench
 
         attr_accessor :screen
 
+        def parse_ansi_segments(text)
+          segments = []
+          remaining = text
+
+          while remaining.length > 0
+            # Look for next ANSI sequence
+            ansi_match = remaining.match(/^(\e\[[0-9;]*m)/)
+
+            if ansi_match
+              # Found ANSI sequence at start
+              segments << {type: :ansi, text: ansi_match[1]}
+              remaining = remaining[ansi_match[1].length..]
+            else
+              # Look for ANSI sequence anywhere in remaining text
+              next_ansi = remaining.match(/(\e\[[0-9;]*m)/)
+
+              if next_ansi
+                # Text before ANSI sequence
+                text_before = remaining[0...next_ansi.begin(1)]
+                if text_before.length > 0
+                  segments << {type: :text, text: text_before}
+                end
+                remaining = remaining[next_ansi.begin(1)..]
+              else
+                # No more ANSI sequences, rest is text
+                segments << {type: :text, text: remaining}
+                break
+              end
+            end
+          end
+
+          segments
+        end
+
         def ansi_to_curses_color(codes)
           # Convert ANSI color codes to curses color pairs
           return nil if codes.empty? || codes == [0]