Add stats panel (silva96#67)

* Add stats panel

* Fix standard

Author: silva96

lib/log_bench/app/main.rb

@@ -68,7 +68,9 @@ def setup_components
 
       def load_initial_data
         self.log_file = Log::File.new(log_file_path)
-        state.requests = log_file.requests
+        initial_requests = log_file.requests
+        state.requests = initial_requests
+        state.set_initial_query_count(initial_requests)
         log_file.mark_as_read!
       end
 

lib/log_bench/app/monitor.rb

@@ -43,6 +43,7 @@ def monitor_loop
       def add_new_requests(new_requests)
         return if new_requests.empty?
 
+        state.track_new_requests(new_requests)
         state.requests.concat(new_requests)
         keep_recent_requests
       end

lib/log_bench/app/renderer/header.rb

@@ -50,30 +50,76 @@ def draw_file_name
         end
 
         def draw_stats
-          filtered_requests = state.filtered_requests
-          total_requests = state.requests.size
-
           if state.main_filter.present?
-            # Filter active - show "X found (Y total)"
-            stats_text = "#{filtered_requests.size} found (#{total_requests} total)"
-            header_win.setpos(1, screen.width - stats_text.length - 2)
-            header_win.attron(color_pair(3)) { header_win.addstr(filtered_requests.size.to_s) }
-            header_win.addstr(" found (")
-            header_win.attron(color_pair(3)) { header_win.addstr(total_requests.to_s) }
-            header_win.addstr(" total)")
+            draw_filtered_stats
           else
-            # No filter active - show simple count
-            stats_text = "Requests: #{total_requests}"
-            header_win.setpos(1, screen.width - stats_text.length - 2)
-            header_win.addstr("Requests: ")
-            header_win.attron(color_pair(3)) { header_win.addstr(total_requests.to_s) }
+            draw_stats_panel
           end
         end
 
+        def draw_filtered_stats
+          # When filter is active, show compact "X found (Y total)" on line 1
+          filtered_requests = state.filtered_requests
+          total_requests = state.requests.size
+          stats_text = "#{filtered_requests.size} found (#{total_requests} total)"
+          header_win.setpos(1, screen.width - stats_text.length - 2)
+          header_win.attron(color_pair(3)) { header_win.addstr(filtered_requests.size.to_s) }
+          header_win.addstr(" found (")
+          header_win.attron(color_pair(3)) { header_win.addstr(total_requests.to_s) }
+          header_win.addstr(" total)")
+        end
+
+        def draw_stats_panel
+          # Calculate stats
+          total_requests = state.requests.size
+          total_queries = state.total_queries
+          req_per_sec = state.requests_per_second
+          req_per_min = state.requests_per_minute
+          queries_per_sec = state.queries_per_second
+          queries_per_min = state.queries_per_minute
+
+          # Calculate width for alignment
+          header_text = "        Total | sec | min"
+          max_width = header_text.length
+          start_x = screen.width - max_width - 2
+
+          # Draw header line (dimmed)
+          header_win.setpos(1, start_x)
+          header_win.attron(A_DIM) { header_win.addstr(header_text) }
+
+          # Draw requests line
+          header_win.setpos(2, start_x)
+          draw_stats_line("Req:   ", total_requests, req_per_sec, req_per_min)
+
+          # Draw queries line
+          header_win.setpos(3, start_x)
+          draw_stats_line("Query: ", total_queries, queries_per_sec, queries_per_min)
+        end
+
+        def draw_stats_line(label, total, per_sec, per_min)
+          # Draw label
+          header_win.addstr(label)
+
+          # Draw total (highlighted, right-aligned in 6 chars)
+          total_str = format("%6d", total)
+          header_win.attron(color_pair(SUCCESS_GREEN)) { header_win.addstr(total_str) }
+          header_win.addstr(" | ")
+
+          # Draw per second (highlighted, right-aligned in 3 chars)
+          per_sec_str = format("%3.0f", per_sec)
+          header_win.attron(color_pair(SUCCESS_GREEN)) { header_win.addstr(per_sec_str) }
+          header_win.addstr(" | ")
+
+          # Draw per minute (highlighted, right-aligned in 3 chars)
+          per_min_str = format("%3.0f", per_min)
+          header_win.attron(color_pair(SUCCESS_GREEN)) { header_win.addstr(per_min_str) }
+        end
+
         def draw_help_text
           header_win.setpos(2, 2)
           header_win.attron(A_DIM) do
-            header_win.addstr("a:Auto-scroll(")
+            help_line_1 = "a:Auto-scroll("
+            header_win.addstr(help_line_1)
             header_win.attron(color_pair(3)) { header_win.addstr(state.auto_scroll ? "ON" : "OFF") }
             header_win.addstr(") | f:Filter | c:Clear filter | s:Sort(")
             header_win.attron(color_pair(3)) { header_win.addstr(state.sort.display_name) }

lib/log_bench/app/state.rb

@@ -7,7 +7,7 @@ module App
     class State
       include Singleton
 
-      attr_reader :main_filter, :sort, :detail_filter, :cleared_requests
+      attr_reader :main_filter, :sort, :detail_filter, :cleared_requests, :start_time, :stats, :total_queries
       attr_accessor :requests, :orphan_requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset, :detail_selected_entry, :text_selection_mode, :update_available, :update_version
 
       def initialize
@@ -32,6 +32,9 @@ def reset!
         self.update_version = nil
         self.cleared_requests = nil
         self.job_ids_map = {}
+        self.start_time = Time.now
+        self.stats = Stats.new
+        self.total_queries = 0
       end
 
       def running?
@@ -91,17 +94,20 @@ def clear_detail_filter
       def clear_requests
         if cleared_requests
           cleared_requests[:requests] += requests
+          cleared_requests[:total_queries] += total_queries
         else
           self.cleared_requests = {
             requests: requests,
             selected: selected,
             scroll_offset: scroll_offset,
             detail_scroll_offset: detail_scroll_offset,
-            detail_selected_entry: detail_selected_entry
+            detail_selected_entry: detail_selected_entry,
+            total_queries: total_queries
           }
         end
 
         self.requests = []
+        self.total_queries = 0
         self.selected = 0
         self.scroll_offset = 0
         self.detail_scroll_offset = 0
@@ -115,6 +121,7 @@ def undo_clear_requests
         restored_requests = cleared_requests[:requests] + requests
 
         self.requests = restored_requests
+        self.total_queries = cleared_requests[:total_queries] + total_queries
         self.selected = cleared_requests[:selected]
         self.scroll_offset = cleared_requests[:scroll_offset]
         self.detail_scroll_offset = cleared_requests[:detail_scroll_offset]
@@ -297,10 +304,40 @@ def request_id_for_job(job_id)
         job_ids_map[job_id]
       end
 
+      def track_new_requests(new_requests)
+        stats.track_requests(new_requests)
+        # Update total queries counter
+        self.total_queries += new_requests.sum(&:query_count)
+      end
+
+      def set_initial_query_count(requests)
+        self.total_queries = requests.sum(&:query_count)
+      end
+
+      def elapsed_time
+        Time.now - start_time
+      end
+
+      def requests_per_second
+        stats.requests_per_second
+      end
+
+      def requests_per_minute
+        stats.requests_per_minute
+      end
+
+      def queries_per_second
+        stats.queries_per_second
+      end
+
+      def queries_per_minute
+        stats.queries_per_minute
+      end
+
       private
 
       attr_accessor :focused_pane, :running, :job_ids_map
-      attr_writer :main_filter, :detail_filter, :sort, :cleared_requests
+      attr_writer :main_filter, :detail_filter, :sort, :cleared_requests, :start_time, :stats, :total_queries
     end
   end
 end

lib/log_bench/app/stats.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module LogBench
+  module App
+    class Stats
+      def initialize
+        self.request_history = []
+        self.last_calculation_time = Time.now
+        self.cached_requests_per_sec = 0.0
+        self.cached_requests_per_min = 0.0
+        self.cached_queries_per_sec = 0.0
+        self.cached_queries_per_min = 0.0
+      end
+
+      def track_requests(new_requests)
+        return if new_requests.empty?
+
+        now = Time.now
+        new_requests.each do |req|
+          request_history << {time: now, queries: req.query_count}
+        end
+      end
+
+      def requests_per_second
+        update_calculations
+        cached_requests_per_sec
+      end
+
+      def requests_per_minute
+        update_calculations
+        cached_requests_per_min
+      end
+
+      def queries_per_second
+        update_calculations
+        cached_queries_per_sec
+      end
+
+      def queries_per_minute
+        update_calculations
+        cached_queries_per_min
+      end
+
+      private
+
+      attr_accessor :request_history, :last_calculation_time
+      attr_accessor :cached_requests_per_sec, :cached_requests_per_min
+      attr_accessor :cached_queries_per_sec, :cached_queries_per_min
+
+      # Update rate calculations based on recent activity using rolling buffer
+      # We calculate per-second rate from last 1 second, per-minute rate from last 60 seconds
+      def update_calculations
+        now = Time.now
+
+        # Only recalculate every 0.5 seconds to avoid excessive computation
+        return if now - last_calculation_time < 0.5
+
+        self.last_calculation_time = now
+
+        # Remove entries older than 60 seconds (we only need last 60 seconds)
+        cutoff_time = now - 60.0
+        request_history.reject! { |entry| entry[:time] < cutoff_time }
+
+        # Count requests and queries in the last 1 second
+        one_sec_cutoff = now - 1.0
+        last_sec_entries = request_history.select { |entry| entry[:time] > one_sec_cutoff }
+        last_sec_count = last_sec_entries.size
+        last_sec_queries = last_sec_entries.sum { |entry| entry[:queries] }
+
+        # Count requests and queries in the last 60 seconds (all remaining entries)
+        last_min_count = request_history.size
+        last_min_queries = request_history.sum { |entry| entry[:queries] }
+
+        # Per-second rate: count from last 1 second
+        self.cached_requests_per_sec = last_sec_count.to_f
+        self.cached_queries_per_sec = last_sec_queries.to_f
+
+        # Per-minute rate: count from last 60 seconds
+        self.cached_requests_per_min = last_min_count.to_f
+        self.cached_queries_per_min = last_min_queries.to_f
+      end
+    end
+  end
+end