log_bench 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08b5b0c6673f13c5ef68af14e5699ac8591d46605a0783e9d9ad70036feaf10e'
-  data.tar.gz: '06338df9398f01ba5c0235c01952c1ee4c59a3ee1b56f555d18441363ecea820'
+  metadata.gz: a7bf1724c565d5848f6867b14ec19675a50594b369cb3d7729d117b310f4d399
+  data.tar.gz: cc2c21dc13a0981b11c92933ecbe967a6cf98b7a7ff21e27d322e156932e42a0
 SHA512:
-  metadata.gz: 2d9c1e13307b411dc4da7839102ef7751414567f066893a1b405b9f4e16a2cd6300da26ecaa1af492ed64ba9d2ccd6134c89a37d596a4faa1b8fc5447239127c
-  data.tar.gz: 0307b86cc997309aba98fc81c93cb0a01ac87c78866d227b9d86716eb8a7486837547516913188af41cc85c331e2dfa85e34985112c71281c59336253392b00c
+  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]

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

@@ -8,6 +8,7 @@ module LogBench
       class Details
         include Curses
         EMPTY_LINE = {text: "", color: nil}
+        SEPARATOR_LINE = {text: "", color: nil, separator: true}
 
         def initialize(screen, state, scrollbar, ansi_renderer)
           self.screen = screen
@@ -26,6 +27,20 @@ module LogBench
           draw_request_details
         end
 
+        def get_cached_detail_lines(request)
+          current_cache_key = build_cache_key(request)
+
+          # Return cached lines if cache is still valid
+          if cached_lines && cache_key == current_cache_key
+            return cached_lines
+          end
+
+          # Cache is invalid, rebuild lines
+          self.cached_lines = build_detail_lines(request)
+          self.cache_key = current_cache_key
+          cached_lines
+        end
+
         private
 
         attr_accessor :screen, :state, :scrollbar, :ansi_renderer, :cached_lines, :cache_key
@@ -60,16 +75,34 @@ module LogBench
           visible_height = detail_win.maxy - 2
 
           adjust_detail_scroll(lines.size, visible_height)
+          state.adjust_detail_scroll_for_entry_selection(visible_height, lines)
+
+          # Find all unique entry IDs and determine selected entry, excluding separator lines
+          entry_ids = lines.reject { |line| line[:separator] }.map { |line| line[:entry_id] }.compact.uniq
+          selected_entry_id = entry_ids[state.detail_selected_entry] if state.detail_selected_entry < entry_ids.size
 
           visible_lines = lines[state.detail_scroll_offset, visible_height] || []
           visible_lines.each_with_index do |line_data, i|
             y = i + 1  # Start at row 1 (after border)
+            # Don't highlight separator lines
+            is_selected = !line_data[:separator] && line_data[:entry_id] == selected_entry_id && state.right_pane_focused?
+
+            # Draw highlight background if selected
+            if is_selected
+              detail_win.setpos(y, 1)
+              detail_win.attron(color_pair(10) | A_DIM) do
+                detail_win.addstr(" " * (detail_win.maxx - 2))
+              end
+            end
+
             detail_win.setpos(y, 2)
 
             # Handle multi-segment lines (for mixed colors)
             if line_data.is_a?(Hash) && line_data[:segments]
               line_data[:segments].each do |segment|
-                if segment[:color]
+                if is_selected
+                  detail_win.attron(color_pair(10) | A_DIM) { detail_win.addstr(segment[:text]) }
+                elsif segment[:color]
                   detail_win.attron(segment[:color]) { detail_win.addstr(segment[:text]) }
                 else
                   detail_win.addstr(segment[:text])
@@ -77,16 +110,26 @@ module LogBench
               end
             elsif line_data.is_a?(Hash) && line_data[:raw_ansi]
               # Handle lines with raw ANSI codes (like colorized SQL)
-              ansi_renderer.parse_and_render(line_data[:text], detail_win)
+              if is_selected
+                # For selected ANSI lines, render without ANSI codes to maintain highlight
+                plain_text = line_data[:text].gsub(/\e\[[0-9;]*m/, "")
+                detail_win.attron(color_pair(10) | A_DIM) { detail_win.addstr(plain_text) }
+              else
+                ansi_renderer.parse_and_render(line_data[:text], detail_win)
+              end
             elsif line_data.is_a?(Hash)
               # Handle single-color lines
-              if line_data[:color]
+              if is_selected
+                detail_win.attron(color_pair(10) | A_DIM) { detail_win.addstr(line_data[:text]) }
+              elsif line_data[:color]
                 detail_win.attron(line_data[:color]) { detail_win.addstr(line_data[:text]) }
               else
                 detail_win.addstr(line_data[:text])
               end
-            else
+            elsif is_selected
               # Simple string
+              detail_win.attron(color_pair(10) | A_DIM) { detail_win.addstr(line_data.to_s) }
+            else
               detail_win.addstr(line_data.to_s)
             end
           end
@@ -97,20 +140,6 @@ module LogBench
           end
         end
 
-        def get_cached_detail_lines(request)
-          current_cache_key = build_cache_key(request)
-
-          # Return cached lines if cache is still valid
-          if cached_lines && cache_key == current_cache_key
-            return cached_lines
-          end
-
-          # Cache is invalid, rebuild lines
-          self.cached_lines = build_detail_lines(request)
-          self.cache_key = current_cache_key
-          cached_lines
-        end
-
         def build_cache_key(request)
           # Cache key includes factors that affect the rendered output
           [
@@ -123,6 +152,7 @@ module LogBench
 
         def build_detail_lines(request)
           lines = []
+          entry_id = 0  # Track logical log entries
           # Cache window width to avoid repeated method calls
           window_width = detail_win.maxx
           max_width = window_width - 6  # Leave margin for borders and scrollbar
@@ -136,10 +166,12 @@ module LogBench
           else color_pair(2) | A_BOLD
           end
 
-          lines << EMPTY_LINE
+          lines << EMPTY_LINE.merge(entry_id: entry_id)
+          entry_id += 1
           lines << {
             text: "Method: #{request.method}",
             color: nil,
+            entry_id: entry_id,
             segments: [
               {text: "Method: ", color: color_pair(1)},
               {text: request.method, color: method_color}
@@ -147,17 +179,23 @@ module LogBench
           }
 
           # Path - allow multiple lines with proper color separation
-          add_path_lines(lines, request, max_width)
-          add_status_duration_lines(lines, request)
-          add_controller_lines(lines, request)
-          add_request_id_lines(lines, request)
-          add_params_lines(lines, request, max_width)
-          add_related_logs_section(lines, request)
+          entry_id += 1
+          add_path_lines(lines, request, max_width, entry_id)
+          entry_id += 1
+          add_status_duration_lines(lines, request, entry_id)
+          entry_id += 1
+          add_controller_lines(lines, request, entry_id)
+          entry_id += 1
+          add_request_id_lines(lines, request, entry_id)
+          entry_id += 1
+          add_params_lines(lines, request, max_width, entry_id)
+          entry_id += 1
+          add_related_logs_section(lines, request, entry_id)
 
           lines
         end
 
-        def add_path_lines(lines, request, max_width)
+        def add_path_lines(lines, request, max_width, entry_id)
           path_prefix = "Path: "
           remaining_path = request.path
 
@@ -167,6 +205,7 @@ module LogBench
             lines << {
               text: path_prefix + remaining_path,
               color: nil,
+              entry_id: entry_id,
               segments: [
                 {text: path_prefix, color: color_pair(1)},
                 {text: remaining_path, color: nil}  # Default white color
@@ -178,6 +217,7 @@ module LogBench
             lines << {
               text: path_prefix + first_chunk,
               color: nil,
+              entry_id: entry_id,
               segments: [
                 {text: path_prefix, color: color_pair(1)},
                 {text: first_chunk, color: nil}  # Default white color
@@ -188,13 +228,13 @@ module LogBench
             # Continue on subsequent lines
             while remaining_path.length > 0
               line_chunk = remaining_path[0, max_width]
-              lines << {text: line_chunk, color: nil}  # Default white color
+              lines << {text: line_chunk, color: nil, entry_id: entry_id}  # Default white color
               remaining_path = remaining_path[max_width..] || ""
             end
           end
         end
 
-        def add_status_duration_lines(lines, request)
+        def add_status_duration_lines(lines, request, entry_id)
           if request.status
             # Add status color coding
             status_color = case request.status
@@ -219,17 +259,19 @@ module LogBench
             lines << {
               text: status_text,
               color: nil,
+              entry_id: entry_id,
               segments: segments
             }
           end
         end
 
-        def add_controller_lines(lines, request)
+        def add_controller_lines(lines, request, entry_id)
           if request.controller
             controller_value = "#{request.controller}##{request.action}"
             lines << {
               text: "Controller: #{controller_value}",
               color: nil,
+              entry_id: entry_id,
               segments: [
                 {text: "Controller: ", color: color_pair(1)},
                 {text: controller_value, color: nil}  # Default white color
@@ -238,13 +280,14 @@ module LogBench
           end
         end
 
-        def add_params_lines(lines, request, max_width)
+        def add_params_lines(lines, request, max_width, entry_id)
           return unless request.params
 
-          lines << EMPTY_LINE
+          lines << EMPTY_LINE.merge(entry_id: entry_id)
           lines << {
             text: "Params:",
             color: nil,
+            entry_id: entry_id,
             segments: [
               {text: "Params:", color: color_pair(1) | A_BOLD}
             ]
@@ -259,7 +302,7 @@ module LogBench
 
           while remaining_text && remaining_text.length > 0
             line_chunk = remaining_text[0, line_width]
-            lines << {text: indent + line_chunk, color: nil}
+            lines << {text: indent + line_chunk, color: nil, entry_id: entry_id}
             remaining_text = remaining_text[line_width..] || ""
           end
         end
@@ -312,11 +355,12 @@ module LogBench
           end
         end
 
-        def add_request_id_lines(lines, request)
+        def add_request_id_lines(lines, request, entry_id)
           if request.request_id
             lines << {
               text: "Request ID: #{request.request_id}",
               color: nil,
+              entry_id: entry_id,
               segments: [
                 {text: "Request ID: ", color: color_pair(1)},
                 {text: request.request_id, color: nil}  # Default white color
@@ -333,7 +377,7 @@ module LogBench
           screen.detail_win
         end
 
-        def add_related_logs_section(lines, request)
+        def add_related_logs_section(lines, request, entry_id)
           # Related Logs (grouped by request_id) - only show non-HTTP request logs
           if request.request_id && request.related_logs && !request.related_logs.empty?
             related_logs = request.related_logs
@@ -341,45 +385,30 @@ module LogBench
             # Apply detail filter to related logs
             filtered_related_logs = filter_related_logs(related_logs)
 
-            # Use memoized query statistics from request object
-            query_stats = build_query_stats_from_request(request)
+            # Use QuerySummary for consistent formatting
+            query_summary = QuerySummary.new(request)
+            query_stats = query_summary.build_stats
 
             # Add query summary
-            lines << EMPTY_LINE
+            lines << EMPTY_LINE.merge(entry_id: entry_id)
 
             # Show filter status in summary if filtering is active
             summary_title = "Query Summary:"
-            lines << {text: summary_title, color: color_pair(1) | A_BOLD}
+            lines << {text: summary_title, color: color_pair(1) | A_BOLD, entry_id: entry_id}
 
             if query_stats[:total_queries] > 0
-              # Build summary line with string interpolation
-              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
-
-              lines << {text: "  #{summary_parts.join(" ")}", color: color_pair(2)}
-
-              # Breakdown by operation type - build array efficiently
-              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
+              # Use QuerySummary methods for consistent formatting
+              summary_line = query_summary.build_summary_line(query_stats)
+              lines << {text: "  #{summary_line}", color: color_pair(2), entry_id: entry_id}
 
-              unless breakdown_parts.empty?
-                lines << {text: "  #{breakdown_parts.join(", ")}", color: color_pair(2)}
+              breakdown_line = query_summary.build_breakdown_line(query_stats)
+              unless breakdown_line.empty?
+                lines << {text: "  #{breakdown_line}", color: color_pair(2), entry_id: entry_id}
               end
             end
 
-            lines << EMPTY_LINE
+            entry_id += 1
+            lines << EMPTY_LINE.merge(entry_id: entry_id)
 
             # Show filtered logs section
             if state.detail_filter.present?
@@ -388,6 +417,7 @@ module LogBench
               lines << {
                 text: logs_title_text,
                 color: nil,
+                entry_id: entry_id,
                 segments: [
                   {text: "Related Logs ", color: color_pair(1) | A_BOLD},
                   {text: count_text, color: A_DIM},
@@ -395,61 +425,37 @@ module LogBench
                 ]
               }
             else
-              lines << {text: "Related Logs:", color: color_pair(1) | A_BOLD}
+              lines << {text: "Related Logs:", color: color_pair(1) | A_BOLD, entry_id: entry_id}
             end
 
-            # Use filtered logs for display
-            filtered_related_logs.each do |related|
-              case related.type
-              when :sql, :cache
-                render_padded_text_with_spacing(related.content, lines, extra_empty_lines: 0)
+            # Use filtered logs for display - group SQL queries with their call source lines
+            i = 0
+            while i < filtered_related_logs.size
+              current_log = filtered_related_logs[i]
+              next_log = filtered_related_logs[i + 1] if i + 1 < filtered_related_logs.size
+
+              entry_id += 1
+
+              # Check if current log is a SQL/cache query followed by a call source line
+              if [:sql, :cache].include?(current_log.type) && next_log && next_log.type == :sql_call_line
+                # Group the query and call source together with the same entry_id
+                render_padded_text_with_spacing(current_log.content, lines, entry_id, extra_empty_lines: 0)
+                render_padded_text_with_spacing(next_log.content, lines, entry_id, extra_empty_lines: 1, use_separator: true)
+                i += 2  # Skip the next log since we processed it
               else
-                render_padded_text_with_spacing(related.content, lines, extra_empty_lines: 1)
+                # Handle standalone logs
+                case current_log.type
+                when :sql, :cache
+                  render_padded_text_with_spacing(current_log.content, lines, entry_id, extra_empty_lines: 0)
+                else
+                  render_padded_text_with_spacing(current_log.content, lines, entry_id, extra_empty_lines: 1)
+                end
+                i += 1
               end
             end
           end
         end
 
-        def build_query_stats_from_request(request)
-          # 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 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
-
         def filter_related_logs(related_logs)
           # Filter related logs (SQL, cache, etc.) in the detail pane
           return related_logs unless state.detail_filter.present?
@@ -479,7 +485,7 @@ module LogBench
           matched_indices.sort.map { |index| related_logs[index] }
         end
 
-        def render_padded_text_with_spacing(text, lines, extra_empty_lines: 1)
+        def render_padded_text_with_spacing(text, lines, entry_id, extra_empty_lines: 1, use_separator: false)
           # Helper function that renders text with padding, breaking long text into multiple lines
           content_width = detail_win.maxx - 8  # Account for padding (4 spaces each side)
 
@@ -497,14 +503,18 @@ module LogBench
           # Render each chunk as a separate line with padding
           text_chunks.each do |chunk|
             lines << if has_ansi
-              {text: "  #{chunk}  ", color: nil, raw_ansi: true}
+              {text: "  #{chunk}  ", color: nil, raw_ansi: true, entry_id: entry_id}
             else
-              {text: "  #{chunk}  ", color: nil}
+              {text: "  #{chunk}  ", color: nil, entry_id: entry_id}
             end
           end
 
           # Add extra empty lines after all chunks
-          extra_empty_lines.times { lines << EMPTY_LINE }
+          if use_separator
+            extra_empty_lines.times { lines << SEPARATOR_LINE }
+          else
+            extra_empty_lines.times { lines << EMPTY_LINE.merge(entry_id: entry_id) }
+          end
         end
 
         def adjust_detail_scroll(total_lines, visible_height)

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

@@ -84,7 +84,7 @@ 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")
+            header_win.addstr("←→/hl:Switch Pane | ↑↓/jk/Click:Navigate | g/G:Top/End | y:Copy highlighted")
           end
         end
 

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

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

data/lib/log_bench/app/state.rb

@@ -4,7 +4,7 @@ module LogBench
   module App
     class State
       attr_reader :main_filter, :sort, :detail_filter
-      attr_accessor :requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset, :text_selection_mode, :update_available, :update_version
+      attr_accessor :requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset, :detail_selected_entry, :text_selection_mode, :update_available, :update_version
 
       def initialize
         self.requests = []
@@ -14,6 +14,7 @@ module LogBench
         self.running = true
         self.focused_pane = :left
         self.detail_scroll_offset = 0
+        self.detail_selected_entry = 0
         self.text_selection_mode = false
         self.main_filter = Filter.new
         self.detail_filter = Filter.new
@@ -65,6 +66,7 @@ module LogBench
       def clear_detail_filter
         detail_filter.clear
         self.detail_scroll_offset = 0
+        self.detail_selected_entry = 0
       end
 
       def cycle_sort_mode
@@ -153,7 +155,7 @@ module LogBench
           self.selected = [selected - 1, 0].max
           self.auto_scroll = false
         else
-          self.detail_scroll_offset = [detail_scroll_offset - 1, 0].max
+          self.detail_selected_entry = [detail_selected_entry - 1, 0].max
         end
       end
 
@@ -163,10 +165,15 @@ module LogBench
           self.selected = [selected + 1, max_index].min
           self.auto_scroll = false
         else
-          self.detail_scroll_offset += 1
+          self.detail_selected_entry += 1
         end
       end
 
+      def reset_detail_selection
+        self.detail_selected_entry = 0
+        self.detail_scroll_offset = 0
+      end
+
       def adjust_scroll_for_selection(visible_height)
         return unless left_pane_focused?
 
@@ -190,6 +197,41 @@ module LogBench
         self.scroll_offset = scroll_offset.clamp(0, max_offset)
       end
 
+      def adjust_detail_scroll_for_entry_selection(visible_height, lines)
+        return unless right_pane_focused?
+
+        # Find all unique entry IDs, excluding separator lines
+        entry_ids = lines.reject { |line| line[:separator] }.map { |line| line[:entry_id] }.compact.uniq
+        max_entry_index = [entry_ids.size - 1, 0].max
+
+        # Ensure detail_selected_entry is within bounds
+        self.detail_selected_entry = detail_selected_entry.clamp(0, max_entry_index)
+
+        # Find the first and last line of the selected entry
+        selected_entry_id = entry_ids[detail_selected_entry]
+        return unless selected_entry_id
+
+        first_line_index = lines.find_index { |line| line[:entry_id] == selected_entry_id }
+        return unless first_line_index
+
+        # Find the last line of the selected entry (including any separator lines that follow)
+        last_line_index = first_line_index
+        (first_line_index + 1...lines.size).each do |i|
+          if lines[i][:entry_id] == selected_entry_id || lines[i][:separator]
+            last_line_index = i
+          else
+            break
+          end
+        end
+
+        # Adjust scroll to keep the entire selected entry visible
+        if first_line_index < detail_scroll_offset
+          self.detail_scroll_offset = first_line_index
+        elsif last_line_index >= detail_scroll_offset + visible_height
+          self.detail_scroll_offset = last_line_index - visible_height + 1
+        end
+      end
+
       private
 
       attr_accessor :focused_pane, :running

data/lib/log_bench/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: log_bench
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Benjamín Silva
 bindir: exe
 cert_chain: []
-date: 2025-08-20 00:00:00.000000000 Z
+date: 2025-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -124,11 +124,14 @@ files:
 - Rakefile
 - exe/log_bench
 - lib/log_bench.rb
+- lib/log_bench/app/clipboard.rb
+- lib/log_bench/app/copy_handler.rb
 - lib/log_bench/app/filter.rb
 - lib/log_bench/app/input_handler.rb
 - lib/log_bench/app/main.rb
 - lib/log_bench/app/monitor.rb
 - lib/log_bench/app/mouse_handler.rb
+- lib/log_bench/app/query_summary.rb
 - lib/log_bench/app/renderer/ansi.rb
 - lib/log_bench/app/renderer/details.rb
 - lib/log_bench/app/renderer/header.rb