log_bench 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2129cbf1d3b38903693c9f13efc70a1d01ab73b668796461a30e46793e6922e6
-  data.tar.gz: 8bc054a8e475485ef2023bf66e30db6353dbfe66cf403a809369723a8ff01f0b
+  metadata.gz: 202c43226cc39fb8457f7c2bce99e17a048aa680bf9594f9186520d34f2852ea
+  data.tar.gz: 8fcd799173130062385dd69ca0c4145d904470af1f95644776c467a06de83438
 SHA512:
-  metadata.gz: a16cd16974c7c83bde07265c51ffcbf77f6c809a19cbdc0206e3613694a89d01a8abab9086ee5a2700be7ee02f2a8c51f961cc711013fa3149e05e9024daa805
-  data.tar.gz: 210d660288a5e921035d51926588e830d8bc0ad3c890a2c68c64455f54b38a5c02b240e774ec8331b1d79712bcd595ed3ff5165d2d04a0e8379152dec5c5e2e9
+  metadata.gz: 0b73a0d54830c2e30567e3b3eaab18d6f3086ee12e6851c1236c62a205986e4aafee729e2114baf128e8d72f94e58831a2c1fc30e24f45aa5666fbffd3407df4
+  data.tar.gz: 78b435a7bbd1b7d9e15ea1e462b3ce4b3267d4d00e75cd4dec7a3859ebf1e45acfd92fdca53855677d3eaaf04e691cf96ed8bd6a56a30e43ca8b28ff3a815e2b

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

@@ -123,13 +123,12 @@ module LogBench
 
         def build_detail_lines(request)
           lines = []
-          max_width = detail_win.maxx - 6  # Leave margin for borders and scrollbar
-
-          # Convert request to log format for compatibility with original implementation
-          log = request_to_log_format(request)
+          # Cache window width to avoid repeated method calls
+          window_width = detail_win.maxx
+          max_width = window_width - 6  # Leave margin for borders and scrollbar
 
           # Method - separate label and value colors
-          method_color = case log[:method]
+          method_color = case request.method
           when "GET" then color_pair(3) | A_BOLD
           when "POST" then color_pair(4) | A_BOLD
           when "PUT" then color_pair(5) | A_BOLD
@@ -139,58 +138,28 @@ module LogBench
 
           lines << EMPTY_LINE
           lines << {
-            text: "Method: #{log[:method]}",
+            text: "Method: #{request.method}",
             color: nil,
             segments: [
               {text: "Method: ", color: color_pair(1)},
-              {text: log[:method], color: method_color}
+              {text: request.method, color: method_color}
             ]
           }
 
           # Path - allow multiple lines with proper color separation
-          add_path_lines(lines, log, max_width)
-          add_status_duration_lines(lines, log)
-          add_controller_lines(lines, log)
-          add_request_id_lines(lines, log)
-          add_params_lines(lines, log, max_width)
-          add_related_logs_section(lines, log)
+          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)
 
           lines
         end
 
-        def request_to_log_format(request)
-          {
-            method: request.method,
-            path: request.path,
-            status: request.status,
-            duration: request.duration,
-            controller: request.controller,
-            action: request.action,
-            params: request.params,
-            request_id: request.request_id,
-            related_logs: build_related_logs(request)
-          }
-        end
-
-        def build_related_logs(request)
-          related = []
-
-          # Add all related logs from the request
-          request.related_logs.each do |log|
-            related << {
-              type: log.type,
-              content: log.content,
-              timing: log.timing,
-              timestamp: log.timestamp
-            }
-          end
-
-          related
-        end
-
-        def add_path_lines(lines, log, max_width)
+        def add_path_lines(lines, request, max_width)
           path_prefix = "Path: "
-          remaining_path = log[:path]
+          remaining_path = request.path
 
           # First line starts after "Path: " (6 characters)
           first_line_width = max_width - path_prefix.length
@@ -225,10 +194,10 @@ module LogBench
           end
         end
 
-        def add_status_duration_lines(lines, log)
-          if log[:status]
+        def add_status_duration_lines(lines, request)
+          if request.status
             # Add status color coding
-            status_color = case log[:status]
+            status_color = case request.status
             when 200..299 then color_pair(3)  # Green
             when 300..399 then color_pair(4)  # Yellow
             when 400..599 then color_pair(6)  # Red
@@ -238,12 +207,12 @@ module LogBench
             # Build segments for mixed coloring
             segments = [
               {text: "Status: ", color: color_pair(1)},
-              {text: log[:status].to_s, color: status_color}
+              {text: request.status.to_s, color: status_color}
             ]
 
-            if log[:duration]
+            if request.duration
               segments << {text: " | Duration: ", color: color_pair(1)}
-              segments << {text: "#{log[:duration]}ms", color: nil}  # Default white color
+              segments << {text: "#{request.duration}ms", color: nil}  # Default white color
             end
 
             status_text = segments.map { |s| s[:text] }.join
@@ -255,9 +224,9 @@ module LogBench
           end
         end
 
-        def add_controller_lines(lines, log)
-          if log[:controller]
-            controller_value = "#{log[:controller]}##{log[:action]}"
+        def add_controller_lines(lines, request)
+          if request.controller
+            controller_value = "#{request.controller}##{request.action}"
             lines << {
               text: "Controller: #{controller_value}",
               color: nil,
@@ -269,8 +238,8 @@ module LogBench
           end
         end
 
-        def add_params_lines(lines, log, max_width)
-          return unless log[:params]
+        def add_params_lines(lines, request, max_width)
+          return unless request.params
 
           lines << EMPTY_LINE
           lines << {
@@ -281,7 +250,7 @@ module LogBench
             ]
           }
 
-          params_text = format_params(log[:params])
+          params_text = format_params(request.params)
           indent = "  "
 
           # Split the params text into lines that fit within the available width
@@ -343,14 +312,14 @@ module LogBench
           end
         end
 
-        def add_request_id_lines(lines, log)
-          if log[:request_id]
+        def add_request_id_lines(lines, request)
+          if request.request_id
             lines << {
-              text: "Request ID: #{log[:request_id]}",
+              text: "Request ID: #{request.request_id}",
               color: nil,
               segments: [
                 {text: "Request ID: ", color: color_pair(1)},
-                {text: log[:request_id], color: nil}  # Default white color
+                {text: request.request_id, color: nil}  # Default white color
               ]
             }
           end
@@ -364,19 +333,16 @@ module LogBench
           screen.detail_win
         end
 
-        def add_related_logs_section(lines, log)
+        def add_related_logs_section(lines, request)
           # Related Logs (grouped by request_id) - only show non-HTTP request logs
-          if log[:request_id] && log[:related_logs] && !log[:related_logs].empty?
-            related_logs = log[:related_logs]
-
-            # Sort by timestamp
-            related_logs.sort_by! { |l| l[:timestamp] || Time.at(0) }
+          if request.request_id && request.related_logs && !request.related_logs.empty?
+            related_logs = request.related_logs
 
             # Apply detail filter to related logs
             filtered_related_logs = filter_related_logs(related_logs)
 
-            # Calculate query statistics (use original logs for stats)
-            query_stats = calculate_query_stats(related_logs)
+            # Use memoized query statistics from request object
+            query_stats = build_query_stats_from_request(request)
 
             # Add query summary
             lines << EMPTY_LINE
@@ -386,30 +352,30 @@ module LogBench
             lines << {text: summary_title, color: color_pair(1) | A_BOLD}
 
             if query_stats[:total_queries] > 0
-              summary_line = "  #{query_stats[:total_queries]} queries"
+              # Build summary line with string interpolation
+              summary_parts = ["#{query_stats[:total_queries]} queries"]
+
               if query_stats[:total_time] > 0
-                summary_line += " (#{query_stats[:total_time]}ms total"
-                if query_stats[:cached_queries] > 0
-                  summary_line += ", #{query_stats[:cached_queries]} cached"
-                end
-                summary_line += ")"
+                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_line += " (#{query_stats[:cached_queries]} cached)"
+                summary_parts << "(#{query_stats[:cached_queries]} cached)"
               end
-              lines << {text: summary_line, color: color_pair(2)}
-
-              # Breakdown by operation type
-              breakdown_parts = []
-              breakdown_parts << "#{query_stats[:select]} SELECT" if query_stats[:select] > 0
-              breakdown_parts << "#{query_stats[:insert]} INSERT" if query_stats[:insert] > 0
-              breakdown_parts << "#{query_stats[:update]} UPDATE" if query_stats[:update] > 0
-              breakdown_parts << "#{query_stats[:delete]} DELETE" if query_stats[:delete] > 0
-              breakdown_parts << "#{query_stats[:transaction]} TRANSACTION" if query_stats[:transaction] > 0
-              breakdown_parts << "#{query_stats[:cache]} CACHE" if query_stats[:cache] > 0
-
-              if !breakdown_parts.empty?
-                breakdown_line = "  " + breakdown_parts.join(", ")
-                lines << {text: breakdown_line, color: color_pair(2)}
+
+              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
+
+              unless breakdown_parts.empty?
+                lines << {text: "  #{breakdown_parts.join(", ")}", color: color_pair(2)}
               end
             end
 
@@ -434,77 +400,56 @@ module LogBench
 
             # Use filtered logs for display
             filtered_related_logs.each do |related|
-              case related[:type]
+              case related.type
               when :sql, :cache
-                render_padded_text_with_spacing(related[:content], lines, extra_empty_lines: 0)
+                render_padded_text_with_spacing(related.content, lines, extra_empty_lines: 0)
               else
-                render_padded_text_with_spacing(related[:content], lines, extra_empty_lines: 1)
+                render_padded_text_with_spacing(related.content, lines, extra_empty_lines: 1)
               end
             end
           end
         end
 
-        def calculate_query_stats(related_logs)
+        def build_query_stats_from_request(request)
+          # Use memoized methods from request object for better performance
           stats = {
-            total_queries: 0,
-            total_time: 0.0,
+            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,
-            cache: 0,
-            cached_queries: 0
+            transaction: 0
           }
 
-          related_logs.each do |log|
-            next unless [:sql, :cache].include?(log[:type])
-
-            stats[:total_queries] += 1
-
-            # Extract timing from the content
-            if log[:timing]
-              # Parse timing like "(1.2ms)" or "1.2ms"
-              timing_str = log[:timing].gsub(/[()ms]/, "")
-              timing_value = timing_str.to_f
-              stats[:total_time] += timing_value
-            end
+          # Categorize by operation type for breakdown
+          request.related_logs.each do |log|
+            next unless [:sql, :cache].include?(log.type)
 
-            # Categorize by SQL operation and check for cache
-            content = log[:content].upcase
-            if content.include?("CACHE")
-              stats[:cached_queries] += 1
-              # Still categorize cached queries by their operation type
-              if content.include?("SELECT")
-                stats[:select] += 1
-              elsif content.include?("INSERT")
-                stats[:insert] += 1
-              elsif content.include?("UPDATE")
-                stats[:update] += 1
-              elsif content.include?("DELETE")
-                stats[:delete] += 1
-              elsif content.include?("TRANSACTION") || content.include?("BEGIN") || content.include?("COMMIT") || content.include?("ROLLBACK")
-                stats[:transaction] += 1
-              end
-            elsif content.include?("SELECT")
-              stats[:select] += 1
-            elsif content.include?("INSERT")
-              stats[:insert] += 1
-            elsif content.include?("UPDATE")
-              stats[:update] += 1
-            elsif content.include?("DELETE")
-              stats[:delete] += 1
-            elsif content.include?("TRANSACTION") || content.include?("BEGIN") || content.include?("COMMIT") || content.include?("ROLLBACK") || content.include?("SAVEPOINT")
-              stats[:transaction] += 1
-            end
+            categorize_sql_operation(log, stats)
           end
 
-          # Round total time to 1 decimal place
-          stats[:total_time] = stats[:total_time].round(1)
-
           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?
@@ -513,27 +458,25 @@ module LogBench
 
           # First pass: find direct matches
           related_logs.each_with_index do |log, index|
-            if log[:content] && state.detail_filter.matches?(log[:content])
-              matched_indices.add(index)
-
-              # Add context lines based on log type
-              case log[:type]
-              when :sql_call_line
-                # If match is a sql_call_line, include the line below (the actual SQL query)
-                if index + 1 < related_logs.size
-                  matched_indices.add(index + 1)
-                end
-              when :sql, :cache
-                # If match is a sql or cache, include the line above (the call stack line)
-                if index > 0 && related_logs[index - 1][:type] == :sql_call_line
-                  matched_indices.add(index - 1)
-                end
+            next unless log.content && state.detail_filter.matches?(log.content)
+
+            matched_indices.add(index)
+
+            # Add context lines based on log type
+            case log.type
+            when :sql_call_line
+              # If match is a sql_call_line, include the line below (the actual SQL query)
+              matched_indices.add(index + 1) if index + 1 < related_logs.size
+            when :sql, :cache
+              # If match is a sql or cache, include the line above (the call stack line)
+              if index > 0 && related_logs[index - 1].type == :sql_call_line
+                matched_indices.add(index - 1)
               end
             end
           end
 
-          # Return logs in original order
-          matched_indices.to_a.sort.map { |index| related_logs[index] }
+          # Return logs in original order - optimize array operations
+          matched_indices.sort.map { |index| related_logs[index] }
         end
 
         def render_padded_text_with_spacing(text, lines, extra_empty_lines: 1)
@@ -561,17 +504,12 @@ module LogBench
           end
 
           # Add extra empty lines after all chunks
-          extra_empty_lines.times do
-            lines << EMPTY_LINE
-          end
-
-          text_chunks.length
+          extra_empty_lines.times { lines << EMPTY_LINE }
         end
 
         def adjust_detail_scroll(total_lines, visible_height)
           max_scroll = [total_lines - visible_height, 0].max
-          state.detail_scroll_offset = [state.detail_scroll_offset, max_scroll].min
-          state.detail_scroll_offset = [state.detail_scroll_offset, 0].max
+          state.detail_scroll_offset = state.detail_scroll_offset.clamp(0, max_scroll)
         end
       end
     end

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

@@ -107,75 +107,70 @@ module LogBench
 
         def draw_row(request, request_index, y_position)
           log_win.setpos(y_position, 1)
+          is_selected = request_index == state.selected
 
-          if request_index == state.selected
+          if is_selected
             log_win.attron(color_pair(10) | A_DIM) do
               log_win.addstr(" " * (screen.panel_width - 4))
             end
             log_win.setpos(y_position, 1)
           end
 
-          draw_method_badge(request, request_index)
-          draw_path_column(request, request_index)
-          draw_status_column(request, request_index)
-          draw_duration_column(request, request_index)
+          draw_method_badge(request, is_selected)
+          draw_path_column(request, is_selected)
+          draw_status_column(request, is_selected)
+          draw_duration_column(request, is_selected)
         end
 
-        def draw_method_badge(request, request_index)
-          method_color = method_color_for(request.method)
+        def draw_method_badge(request, is_selected)
+          method_text = " #{request.method.ljust(7)} "
 
-          if request_index == state.selected
-            log_win.attron(color_pair(10) | A_DIM) do
-              log_win.addstr(" #{request.method.ljust(7)} ")
-            end
+          if is_selected
+            log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(method_text) }
           else
-            log_win.attron(color_pair(method_color) | A_BOLD) do
-              log_win.addstr(" #{request.method.ljust(7)} ")
-            end
+            method_color = method_color_for(request.method)
+            log_win.attron(color_pair(method_color) | A_BOLD) { log_win.addstr(method_text) }
           end
         end
 
-        def draw_path_column(request, request_index)
+        def draw_path_column(request, is_selected)
           path_width = screen.panel_width - 27
           path = request.path[0, path_width] || ""
+          path_text = path.ljust(path_width)
 
-          if request_index == state.selected
-            log_win.attron(color_pair(10) | A_DIM) do
-              log_win.addstr(path.ljust(path_width))
-            end
+          if is_selected
+            log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(path_text) }
           else
-            log_win.addstr(path.ljust(path_width))
+            log_win.addstr(path_text)
           end
         end
 
-        def draw_status_column(request, request_index)
+        def draw_status_column(request, is_selected)
+          return unless request.status
+
           status_col_start = screen.panel_width - 14
+          status_text = "#{request.status.to_s.rjust(3)} "
 
-          if request.status
+          log_win.setpos(log_win.cury, status_col_start)
+          if is_selected
+            log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(status_text) }
+          else
             status_color = status_color_for(request.status)
-            status_text = request.status.to_s.rjust(3)
-
-            log_win.setpos(log_win.cury, status_col_start)
-            if request_index == state.selected
-              log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(status_text + " ") }
-            else
-              log_win.attron(color_pair(status_color)) { log_win.addstr(status_text + " ") }
-            end
+            log_win.attron(color_pair(status_color)) { log_win.addstr(status_text) }
           end
         end
 
-        def draw_duration_column(request, request_index)
-          duration_col_start = screen.panel_width - 9
+        def draw_duration_column(request, is_selected)
+          return unless request.duration
 
-          if request.duration
-            duration_text = "#{request.duration.to_i}ms".ljust(6)
+          duration_col_start = screen.panel_width - 9
+          duration_text = "#{request.duration.to_i}ms".ljust(6) + " "
 
-            log_win.setpos(log_win.cury, duration_col_start)
-            if request_index == state.selected
-              log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(duration_text + " ") }
-            else
-              log_win.attron(A_DIM) { log_win.addstr(duration_text + " ") }
-            end
+          log_win.setpos(log_win.cury, duration_col_start)
+          if is_selected
+            log_win.attron(color_pair(10) | A_DIM) { log_win.addstr(duration_text) }
+          else
+            log_win.attron(A_DIM) { log_win.addstr(duration_text) }
           end
         end
 

data/lib/log_bench/log/call_line_entry.rb

@@ -17,15 +17,6 @@ module LogBench
         new(raw_line)
       end
 
-      def to_h
-        super.merge(
-          content: content,
-          file_path: file_path,
-          line_number: line_number,
-          method_name: method_name
-        )
-      end
-
       private
 
       attr_accessor :file_path, :line_number, :method_name

data/lib/log_bench/log/collection.rb

@@ -27,14 +27,6 @@ module LogBench
         entries.select { |entry| entry.is_a?(Request) }
       end
 
-      def queries
-        entries.flat_map(&:queries)
-      end
-
-      def cache_operations
-        entries.flat_map(&:cache_operations)
-      end
-
       def filter_by_method(method)
         filtered_requests = requests.select { |req| req.method == method.upcase }
         create_collection_from_requests(filtered_requests)

data/lib/log_bench/log/entry.rb

@@ -31,15 +31,6 @@ module LogBench
         !http_request?
       end
 
-      def to_h
-        {
-          raw: raw_line,
-          timestamp: timestamp,
-          request_id: request_id,
-          type: type
-        }
-      end
-
       private
 
       attr_writer :type, :raw_line, :timestamp, :request_id, :content, :timing

data/lib/log_bench/log/parser.rb

@@ -23,10 +23,8 @@ module LogBench
         case entry.type
         when :http_request
           Request.build(entry.raw_line)
-        when :sql
+        when :sql, :cache
           QueryEntry.build(entry.raw_line)
-        when :cache
-          CacheEntry.build(entry.raw_line)
         when :sql_call_line
           CallLineEntry.build(entry.raw_line)
         else

data/lib/log_bench/log/query_entry.rb

@@ -14,24 +14,25 @@ module LogBench
       SAVEPOINT = "SAVEPOINT"
       SQL_OPERATIONS = [SELECT, INSERT, UPDATE, DELETE, TRANSACTION, BEGIN_TRANSACTION, COMMIT, ROLLBACK, SAVEPOINT].freeze
 
-      def initialize(raw_line)
-        super
-        self.type = :sql
+      def initialize(raw_line, cached: false)
+        super(raw_line)
+        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 entry.type == :sql
+        return unless [:sql, :cache].include?(entry.type)
 
-        new(raw_line)
+        # Create QueryEntry for both SQL and CACHE entries
+        cached = entry.type == :cache
+        new(raw_line, cached: cached)
       end
 
       def duration_ms
-        return 0.0 unless timing
-
-        timing.gsub(/[()ms]/, "").to_f
+        @duration_ms ||= calculate_duration_ms
       end
 
       def select?
@@ -70,28 +71,24 @@ module LogBench
         operation == SAVEPOINT
       end
 
-      def slow?(threshold_ms = 100)
-        duration_ms > threshold_ms
+      def cached?
+        @cached
       end
 
-      def to_h
-        super.merge(
-          content: content,
-          timing: timing,
-          operation: operation,
-          duration_ms: duration_ms,
-          has_ansi: has_ansi_codes?(content)
-        )
+      def hit?
+        cached? && content.include?("CACHE")
       end
 
       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)
+        return false unless sql_message?(data) || cache_message?(data)
 
         self.content = message.strip
         extract_timing_and_operation
@@ -99,31 +96,48 @@ module LogBench
       end
 
       def extract_timing_and_operation
-        clean_content = remove_ansi_codes(content)
-        self.timing = extract_timing(clean_content)
-        self.operation = extract_operation(clean_content)
+        self.timing = extract_timing
+        self.operation = extract_operation
       end
 
-      def extract_timing(text)
-        match = text.match(/\(([0-9.]+ms)\)/)
+      def extract_timing
+        match = clean_content.match(/\(([0-9.]+ms)\)/)
         match ? match[1] : nil
       end
 
-      def extract_operation(text)
-        SQL_OPERATIONS.find { |op| text.include?(op) }
+      def extract_operation
+        SQL_OPERATIONS.find { |op| clean_content.include?(op) }
       end
 
-      def remove_ansi_codes(text)
-        text.gsub(/\e\[[0-9;]*m/, "")
+      def clean_content
+        @clean_content ||= content&.gsub(/\e\[[0-9;]*m/, "") || ""
       end
 
-      def has_ansi_codes?(text)
-        text.match?(/\e\[[0-9;]*m/)
+      def has_ansi_codes?
+        @has_ansi_codes ||= content&.match?(/\e\[[0-9;]*m/) || false
       end
 
-      private
+      def calculate_duration_ms
+        return 0.0 unless timing
 
-      attr_accessor :operation
+        timing.gsub(/[()ms]/, "").to_f
+      end
+
+      def clear_memoized_values
+        @duration_ms = nil
+        @clean_content = nil
+        @has_ansi_codes = nil
+      end
+
+      def content=(value)
+        super
+        clear_memoized_values
+      end
+
+      def timing=(value)
+        super
+        clear_memoized_values
+      end
     end
   end
 end

data/lib/log_bench/log/request.rb

@@ -3,8 +3,7 @@
 module LogBench
   module Log
     class Request < Entry
-      attr_reader :method, :path, :status, :duration, :controller, :action, :params
-      attr_accessor :related_logs
+      attr_reader :method, :path, :status, :duration, :controller, :action, :params, :related_logs
 
       def initialize(raw_line)
         super
@@ -21,28 +20,34 @@ module LogBench
       end
 
       def add_related_log(log_entry)
-        related_logs << log_entry if log_entry.related_log?
-        self.related_logs = related_logs.sort_by(&:timestamp)
+        if log_entry.related_log?
+          related_logs << log_entry
+          clear_memoized_values
+        end
       end
 
       def queries
-        related_logs.select { |log| log.is_a?(QueryEntry) }
+        @queries ||= related_logs.select { |log| log.is_a?(QueryEntry) }
       end
 
       def cache_operations
-        related_logs.select { |log| log.is_a?(CacheEntry) }
+        @cache_operations ||= related_logs.select { |log| log.is_a?(QueryEntry) && log.cached? }
+      end
+
+      def sql_queries
+        @sql_queries ||= related_logs.select { |log| log.is_a?(QueryEntry) && !log.cached? }
       end
 
       def query_count
-        queries.size
+        @query_count ||= queries.size
       end
 
       def total_query_time
-        queries.sum(&:duration_ms)
+        @total_query_time ||= queries.sum(&:duration_ms)
       end
 
       def cached_query_count
-        cache_operations.size
+        @cached_query_count ||= cache_operations.size
       end
 
       def success?
@@ -57,23 +62,23 @@ module LogBench
         status && status >= 500
       end
 
-      def to_h
-        super.merge(
-          method: method,
-          path: path,
-          status: status,
-          duration: duration,
-          controller: controller,
-          action: action,
-          params: params,
-          related_logs: related_logs.map(&:to_h)
-        )
-      end
-
       private
 
       attr_writer :method, :path, :status, :duration, :controller, :action, :params
 
+      def related_logs=(value)
+        @related_logs = value
+        clear_memoized_values
+      end
+
+      def clear_memoized_values
+        @queries = nil
+        @cache_operations = nil
+        @query_count = nil
+        @total_query_time = nil
+        @cached_query_count = nil
+      end
+
       def extract_from_json(data)
         return false unless super
 

data/lib/log_bench/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: log_bench
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Benjamín Silva
 bindir: exe
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 2025-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -143,7 +143,6 @@ files:
 - lib/log_bench/configuration_validator.rb
 - lib/log_bench/current.rb
 - lib/log_bench/json_formatter.rb
-- lib/log_bench/log/cache_entry.rb
 - lib/log_bench/log/call_line_entry.rb
 - lib/log_bench/log/collection.rb
 - lib/log_bench/log/entry.rb

data/lib/log_bench/log/cache_entry.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module LogBench
-  module Log
-    class CacheEntry < Entry
-      SQL_OPERATIONS = %w[SELECT INSERT UPDATE DELETE].freeze
-
-      def initialize(raw_line)
-        super
-        self.type = :cache
-      end
-
-      def self.build(raw_line)
-        return unless parseable?(raw_line)
-
-        entry = Entry.new(raw_line)
-        return unless entry.type == :cache
-
-        new(raw_line)
-      end
-
-      def duration_ms
-        return 0.0 unless timing
-
-        timing.gsub(/[()ms]/, "").to_f
-      end
-
-      def hit?
-        content.include?("CACHE")
-      end
-
-      def miss?
-        !hit?
-      end
-
-      def to_h
-        super.merge(
-          content: content,
-          timing: timing,
-          operation: operation,
-          duration_ms: duration_ms,
-          hit: hit?
-        )
-      end
-
-      private
-
-      attr_writer :operation
-
-      def extract_from_json(data)
-        super
-        message = data["message"] || ""
-        return unless cache_message?(data)
-
-        self.content = message.strip
-        extract_timing_and_operation
-      end
-
-      def extract_timing_and_operation
-        clean_content = remove_ansi_codes(content)
-        self.timing = extract_timing(clean_content)
-        self.operation = extract_operation(clean_content)
-      end
-
-      def extract_timing(text)
-        match = text.match(/\(([0-9.]+ms)\)/)
-        match ? match[1] : nil
-      end
-
-      def extract_operation(text)
-        SQL_OPERATIONS.find { |op| text.include?(op) }
-      end
-
-      def remove_ansi_codes(text)
-        text.gsub(/\e\[[0-9;]*m/, "")
-      end
-    end
-  end
-end