ruby_llm-agents 3.15.1 → 3.16.0

data/app/controllers/ruby_llm/agents/executions_controller.rb

@@ -22,6 +22,9 @@ module RubyLLM
       CSV_COLUMNS = %w[id agent_type status model_id total_tokens total_cost
         duration_ms created_at error_class error_message].freeze
 
+      # Seconds the totals strip may spend before the list renders without it
+      TOTALS_TIMEOUT = 1
+
       # Lists all executions with filtering and pagination
       #
       # @return [void]
@@ -39,7 +42,7 @@ module RubyLLM
       #
       # @return [void]
       def show
-        @execution = tenant_scoped_executions.includes(:detail, :child_executions).find(params[:id])
+        @execution = tenant_scoped_executions.includes(:detail).find(params[:id])
       end
 
       # Handles filter search requests via Turbo Stream
@@ -83,7 +86,7 @@ module RubyLLM
         self.response_body = Enumerator.new do |yielder|
           yielder << CSV.generate_line(CSV_COLUMNS)
 
-          filtered_executions.find_each(batch_size: 1000) do |execution|
+          filtered_executions.preload(:error_detail).find_each(batch_size: 1000) do |execution|
             yielder << generate_csv_row(execution)
           end
         end
@@ -124,50 +127,35 @@ module RubyLLM
         @statuses = Execution.statuses.keys
       end
 
-      # Returns distinct agent types from execution history
-      #
-      # Memoized to avoid duplicate queries within a request.
-      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
-      #
-      # @return [Array<String>] Agent type names
-      def available_agent_types
-        @available_agent_types ||= tenant_scoped_executions.distinct.pluck(:agent_type)
-      end
-
-      # Returns distinct model IDs from execution history
-      #
-      # Memoized to avoid duplicate queries within a request.
-      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
-      #
-      # @return [Array<String>] Model IDs
-      def available_model_ids
-        @available_model_ids ||= tenant_scoped_executions.where.not(model_id: nil).distinct.pluck(:model_id).sort
-      end
-
       # Loads paginated executions and associated statistics
       #
       # Sets @executions, @pagination, @sort_params, and @filter_stats instance variables
       # for use in views.
       #
+      # The list itself is an index walk and stays fast at any table size. The
+      # totals strip is not: it sums every execution the filters match, which
+      # with no time range is the whole table. So the totals are best-effort
+      # and cached — when the database cannot produce them in TOTALS_TIMEOUT
+      # the strip shows a placeholder and pagination falls back to prev/next,
+      # instead of the page waiting on (or timing out behind) an aggregate.
+      #
       # @return [void]
       def load_executions_with_stats
         @sort_params = parse_sort_params
-        result = paginate(filtered_executions, sort_params: @sort_params)
+        scope = filtered_executions
+
+        filters = request.query_parameters.except("page", "sort", "direction")
+        @filter_stats = cached_stats(:executions_totals, filters.to_query) do
+          Execution.best_effort(timeout: TOTALS_TIMEOUT) { scope.totals }
+        end
+
+        # The count from the same aggregate drives pagination, so a page
+        # never runs a separate COUNT.
+        result = paginate(scope.preload(:error_detail),
+          sort_params: @sort_params,
+          total_count: @filter_stats&.fetch(:total_count))
         @executions = result[:records]
         @pagination = result[:pagination]
-        load_filter_stats
-      end
-
-      # Calculates aggregate statistics for the current filter
-      #
-      # @return [void]
-      def load_filter_stats
-        scope = filtered_executions
-        @filter_stats = {
-          total_count: scope.count,
-          total_cost: scope.sum(:total_cost) || 0,
-          total_tokens: scope.sum(:total_tokens) || 0
-        }
       end
 
       # Builds a filtered execution scope based on request params
@@ -212,11 +200,7 @@ module RubyLLM
         scope = scope.where("attempts_count > 1") if params[:has_retries].present?
 
         # Only show root executions - children are nested under parents
-        scope = scope.where(parent_execution_id: nil)
-
-        # Eager load children for grouping and detail for error_message, which
-        # the list renders per row (otherwise an N+1 on error rows).
-        scope.includes(:child_executions, :detail)
+        scope.where(parent_execution_id: nil)
       end
 
       # Checks whether turbo-rails is available in the host application

data/app/controllers/ruby_llm/agents/requests_controller.rb

@@ -11,43 +11,43 @@ module RubyLLM
     class RequestsController < ApplicationController
       include Paginatable
 
+      # Seconds the header totals may spend before the list renders without them
+      TOTALS_TIMEOUT = 1
+
+      # Progressively wider windows searched for the most recent requests
+      RECENT_WINDOWS = [1.day, 7.days, 30.days].freeze
+
       # Lists all tracked requests with aggregated stats
       #
+      # A request is a GROUP BY over its executions, so listing "the latest
+      # 25" naively aggregates every tracked execution ever recorded before
+      # it can sort. Two things keep the default view off that path: the
+      # page of request ids is found in a recent window first (see
+      # #recent_request_ids) and only those requests are aggregated, and the
+      # header totals are best-effort.
+      #
       # @return [void]
       def index
         @sort_column = sanitize_sort_column(params[:sort])
         @sort_direction = (params[:direction] == "asc") ? "asc" : "desc"
 
-        scope = Execution
-          .where.not(request_id: [nil, ""])
-          .select(
-            "request_id",
-            "COUNT(*) AS call_count",
-            "SUM(total_cost) AS total_cost",
-            "SUM(total_tokens) AS total_tokens",
-            "MIN(started_at) AS started_at",
-            "MAX(completed_at) AS completed_at",
-            "SUM(duration_ms) AS total_duration_ms",
-            "GROUP_CONCAT(DISTINCT agent_type) AS agent_types_list",
-            "GROUP_CONCAT(DISTINCT status) AS statuses_list",
-            "MAX(created_at) AS latest_created_at"
-          )
-          .group(:request_id)
-
-        # Apply time filter
+        tracked = Execution.where.not(request_id: [nil, ""])
         days = params[:days].to_i
-        scope = scope.where("created_at >= ?", days.days.ago) if days > 0
+        tracked = tracked.where("created_at >= ?", days.days.ago) if days > 0
+
+        # One query for the distinct request count and total cost; the count
+        # is shared with pagination instead of being run a second time.
+        @stats = cached_stats(:requests_totals, days) do
+          Execution.best_effort(timeout: TOTALS_TIMEOUT) do
+            total_requests, total_cost = tracked
+              .pick(Arel.sql("COUNT(DISTINCT request_id)"), Arel.sql("COALESCE(SUM(total_cost), 0)"))
+            {total_requests: total_requests.to_i, total_cost: (total_cost || 0).to_d.round(6)}
+          end
+        end
 
-        result = paginate_requests(scope)
+        result = paginate_requests(tracked, total_count: @stats&.fetch(:total_requests))
         @requests = result[:records]
         @pagination = result[:pagination]
-
-        # Stats
-        total_scope = Execution.where.not(request_id: [nil, ""])
-        @stats = {
-          total_requests: total_scope.distinct.count(:request_id),
-          total_cost: total_scope.sum(:total_cost) || 0
-        }
       end
 
       # Shows a single tracked request with all its executions
@@ -55,9 +55,16 @@ module RubyLLM
       # @return [void]
       def show
         @request_id = params[:id]
+
+        # Loaded once: the summary is derived from the same handful of rows
+        # the page lists, instead of nine more queries against them. (Two of
+        # those were DISTINCT plucks on an ordered relation, which PostgreSQL
+        # rejects, so this page raised there.)
         @executions = Execution
           .where(request_id: @request_id)
+          .preload(:error_detail)
           .order(started_at: :asc)
+          .to_a
 
         if @executions.empty?
           redirect_to ruby_llm_agents.requests_path,
@@ -66,15 +73,15 @@ module RubyLLM
         end
 
         @summary = {
-          call_count: @executions.count,
-          total_cost: @executions.sum(:total_cost) || 0,
-          total_tokens: @executions.sum(:total_tokens) || 0,
-          started_at: @executions.minimum(:started_at),
-          completed_at: @executions.maximum(:completed_at),
-          agent_types: @executions.distinct.pluck(:agent_type),
-          models_used: @executions.distinct.pluck(:model_id),
-          all_successful: @executions.where.not(status: "success").count.zero?,
-          error_count: @executions.where(status: "error").count
+          call_count: @executions.size,
+          total_cost: @executions.sum { |e| e.total_cost || 0 },
+          total_tokens: @executions.sum { |e| e.total_tokens || 0 },
+          started_at: @executions.filter_map(&:started_at).min,
+          completed_at: @executions.filter_map(&:completed_at).max,
+          agent_types: @executions.map(&:agent_type).uniq,
+          models_used: @executions.map(&:model_id).uniq,
+          all_successful: @executions.all?(&:status_success?),
+          error_count: @executions.count(&:status_error?)
         }
 
         if @summary[:started_at] && @summary[:completed_at]
@@ -90,25 +97,90 @@ module RubyLLM
         ALLOWED_SORT_COLUMNS.include?(column) ? column : "latest_created_at"
       end
 
-      def paginate_requests(scope)
-        page = [(params[:page] || 1).to_i, 1].max
-        per_page = RubyLLM::Agents.configuration.per_page
+      # Comma-separated DISTINCT values of a column per group.
+      # GROUP_CONCAT exists on SQLite and MySQL; PostgreSQL spells it STRING_AGG.
+      def distinct_list_sql(column)
+        if Execution.connection.adapter_name.downcase.include?("postg")
+          "STRING_AGG(DISTINCT #{column}, ',')"
+        else
+          "GROUP_CONCAT(DISTINCT #{column})"
+        end
+      end
 
-        total_count = Execution
-          .where.not(request_id: [nil, ""])
-          .distinct
-          .count(:request_id)
+      # Aggregates executions into one row per request
+      def request_rows(scope)
+        scope
+          .select(
+            "request_id",
+            "COUNT(*) AS call_count",
+            "SUM(total_cost) AS total_cost",
+            "SUM(total_tokens) AS total_tokens",
+            "MIN(started_at) AS started_at",
+            "MAX(completed_at) AS completed_at",
+            "SUM(duration_ms) AS total_duration_ms",
+            "#{distinct_list_sql("agent_type")} AS agent_types_list",
+            "#{distinct_list_sql("status")} AS statuses_list",
+            "MAX(created_at) AS latest_created_at"
+          )
+          .group(:request_id)
+      end
 
-        sorted = scope.order("#{@sort_column} #{@sort_direction.upcase}")
+      # Request ids for one page of the newest-first list
+      #
+      # The requests active most recently are, by definition, the ones with
+      # an execution in the most recent stretch of time. So instead of
+      # ranking every request, rank the ones seen in the last day; if that
+      # does not fill the page, the last week; and so on, ending with no
+      # bound at all. Each attempt is a bounded read of the created_at index,
+      # and the first one that fills the page is exact.
+      #
+      # @param tracked [ActiveRecord::Relation] Executions that carry a request_id
+      # @param offset [Integer] Requests to skip
+      # @param limit [Integer] Requests to return
+      # @return [Array<String>] Request ids, newest activity first
+      def recent_request_ids(tracked, offset:, limit:)
+        [*RECENT_WINDOWS, nil].each do |window|
+          scope = window ? tracked.where("created_at >= ?", window.ago) : tracked
+          ids = scope.group(:request_id)
+            .order(Arel.sql("MAX(created_at) DESC"))
+            .offset(offset).limit(limit)
+            .pluck(:request_id)
+
+          return ids if ids.size >= limit || window.nil?
+        end
+      end
+
+      # Loads one page of requests
+      #
+      # Fetches one row more than the page holds, so a next page can be
+      # detected when the total count is unavailable.
+      #
+      # @param tracked [ActiveRecord::Relation] Executions that carry a request_id
+      # @param total_count [Integer, nil] Distinct requests, when known
+      # @return [Hash] :records and :pagination, as Paginatable#paginate
+      def paginate_requests(tracked, total_count:)
+        page = [(params[:page] || 1).to_i, 1].max
+        per_page = RubyLLM::Agents.configuration.per_page
         offset = (page - 1) * per_page
 
+        records = if @sort_column == "latest_created_at" && @sort_direction == "desc"
+          ids = recent_request_ids(tracked, offset: offset, limit: per_page + 1)
+          request_rows(tracked.where(request_id: ids)).sort_by { |row| ids.index(row.request_id) }
+        else
+          # Sorting on an aggregate has to aggregate every request first.
+          request_rows(tracked)
+            .order("#{@sort_column} #{@sort_direction.upcase}")
+            .offset(offset).limit(per_page + 1).to_a
+        end
+
         {
-          records: sorted.offset(offset).limit(per_page),
+          records: records.first(per_page),
           pagination: {
             current_page: page,
             per_page: per_page,
             total_count: total_count,
-            total_pages: (total_count.to_f / per_page).ceil
+            total_pages: total_count && (total_count.to_f / per_page).ceil,
+            next_page: records.size > per_page
           }
         }
       end

data/app/controllers/ruby_llm/agents/tenants_controller.rb

@@ -38,14 +38,27 @@ module RubyLLM
 
       # Shows a single tenant's budget details
       #
+      # Usage figures cover the current month, from one grouped scan of it
+      # (see Execution.breakdown). A tenant's executions are scattered across
+      # the whole table, so the all-time versions of these figures were the
+      # most expensive queries in the dashboard.
+      #
       # @return [void]
       def show
         @tenant = TenantBudget.find(params[:id])
-        @executions = tenant_executions(@tenant.tenant_id).recent.limit(10)
-        @usage_stats = calculate_usage_stats(@tenant)
-        @usage_by_agent = @tenant.usage_by_agent(period: nil)
-        @usage_by_model = @tenant.usage_by_model(period: nil)
-        load_tenant_analytics
+        @executions = tenant_executions(@tenant.tenant_id).preload(:error_detail).recent(10)
+
+        month = Execution::Breakdown.new(cached_tenant_stats(:month) do
+          @tenant.executions.where(created_at: Time.current.all_month).breakdown.rows
+        end)
+        @usage_stats = calculate_usage_stats(@tenant, month)
+        @usage_by_agent = month.agent_stats.transform_values do |stats|
+          {cost: stats[:total_cost], tokens: stats[:total_tokens], count: stats[:count]}
+        end
+        @usage_by_model = month.configured_model_usage.to_h do |usage|
+          [usage[:model_id], {cost: usage[:cost], tokens: usage[:tokens], count: usage[:runs]}]
+        end
+        load_tenant_analytics(month)
       end
 
       # Renders the edit form for a tenant budget
@@ -101,45 +114,56 @@ module RubyLLM
         Execution.by_tenant(tenant_id)
       end
 
+      # Caches one of the tenant page's figures
+      def cached_tenant_stats(name, expires_in: 5.minutes, &block)
+        cached_stats(:tenant, @tenant.tenant_id, name, expires_in: expires_in, &block)
+      end
+
       # Calculates usage statistics for a tenant
       #
       # @param tenant [TenantBudget] The tenant budget record
-      # @return [Hash] Usage statistics
-      def calculate_usage_stats(tenant)
-        scope = tenant_executions(tenant.tenant_id)
-        today_scope = scope.where("created_at >= ?", Time.current.beginning_of_day)
-        month_scope = scope.where("created_at >= ?", Time.current.beginning_of_month)
-
-        daily_spend = today_scope.sum(:total_cost) || 0
-        monthly_spend = month_scope.sum(:total_cost) || 0
-        daily_tokens = today_scope.sum(:total_tokens) || 0
-        monthly_tokens = month_scope.sum(:total_tokens) || 0
+      # @param month [Execution::Breakdown] The tenant's executions this month
+      # @return [Hash] Usage statistics; the total_* keys cover this month
+      def calculate_usage_stats(tenant, month)
+        totals = month.totals
+        daily_spend, daily_tokens = tenant_executions(tenant.tenant_id)
+          .where("created_at >= ?", Time.current.beginning_of_day)
+          .pick(Arel.sql("COALESCE(SUM(total_cost), 0)"), Arel.sql("COALESCE(SUM(total_tokens), 0)"))
 
         {
           daily_spend: daily_spend,
-          monthly_spend: monthly_spend,
+          monthly_spend: totals[:cost],
           daily_tokens: daily_tokens,
-          monthly_tokens: monthly_tokens,
+          monthly_tokens: totals[:tokens],
           daily_spend_percentage: percentage_used(daily_spend, tenant.effective_daily_limit),
-          monthly_spend_percentage: percentage_used(monthly_spend, tenant.effective_monthly_limit),
+          monthly_spend_percentage: percentage_used(totals[:cost], tenant.effective_monthly_limit),
           daily_token_percentage: percentage_used(daily_tokens, tenant.effective_daily_token_limit),
-          monthly_token_percentage: percentage_used(monthly_tokens, tenant.effective_monthly_token_limit),
-          total_executions: scope.count,
-          total_cost: scope.sum(:total_cost) || 0,
-          total_tokens: scope.sum(:total_tokens) || 0
+          monthly_token_percentage: percentage_used(totals[:tokens], tenant.effective_monthly_token_limit),
+          total_executions: totals[:total],
+          total_cost: totals[:cost],
+          total_tokens: totals[:tokens],
+          success_count: totals[:success]
         }
       end
 
       # Loads trend data and period comparison for the tenant analytics section.
       #
+      # @param month [Execution::Breakdown] The tenant's executions this month
       # @return [void]
-      def load_tenant_analytics
+      def load_tenant_analytics(month)
         # 30-day daily cost/tokens trend
-        @daily_trend = @tenant.usage_by_day(period: 30.days.ago..Time.current)
+        @daily_trend = cached_tenant_stats(:daily_trend) do
+          @tenant.usage_by_day(period: 30.days.ago..Time.current)
+        end
 
-        # Period comparison: this month vs last month
-        this_month = @tenant.usage_summary(period: :this_month)
-        last_month = @tenant.usage_summary(period: :last_month)
+        # Period comparison: this month vs last month. Last month no longer
+        # changes, so one aggregate of it is kept for an hour.
+        totals = month.totals
+        last = cached_tenant_stats(:last_month, expires_in: 1.hour) do
+          @tenant.executions.where(created_at: 1.month.ago.all_month).totals
+        end
+        this_month = {cost: totals[:cost], tokens: totals[:tokens], executions: totals[:total]}
+        last_month = {cost: last[:total_cost], tokens: last[:total_tokens], executions: last[:total_count]}
         @period_comparison = {
           this_month: this_month,
           last_month: last_month,
@@ -153,10 +177,10 @@ module RubyLLM
           @period_comparison[:avg_cost_last], @period_comparison[:avg_cost_this]
         )
 
-        # Error cost: money spent on failed executions
-        error_scope = @tenant.executions.where(status: "error")
-        @error_cost = error_scope.sum(:total_cost) || 0
-        @error_count = error_scope.count
+        # Error cost: money spent on failed executions this month
+        error_cost = month.error_cost
+        @error_cost = error_cost[:total_cost]
+        @error_count = error_cost[:total_count]
       end
 
       # Calculates percentage change between two values
@@ -167,25 +191,21 @@ module RubyLLM
         ((new_val.to_f - old_val.to_f) / old_val.to_f * 100).round(1)
       end
 
-      # Preloads cost and last-execution data for all tenants in one query each,
-      # avoiding N+1 queries in the index view.
+      # Builds the cost and last-execution lookups for the index view
+      #
+      # Read from the counter columns each tenant row already carries (they
+      # are updated on every execution), rather than by grouping the whole
+      # executions table by tenant. Cost is month-to-date; a counter that has
+      # not been reset yet this month belongs to an earlier one.
       #
       # @return [void]
       def preload_tenant_index_data
-        @tenant_costs = {}
-        @tenant_last_executions = {}
-        tenant_ids = @tenants.map(&:tenant_id)
-        return if tenant_ids.empty?
-
-        # Batch-load total cost per tenant
-        @tenant_costs = Execution.where(tenant_id: tenant_ids)
-          .group(:tenant_id)
-          .sum(:total_cost)
-
-        # Batch-load last execution time per tenant
-        @tenant_last_executions = Execution.where(tenant_id: tenant_ids)
-          .group(:tenant_id)
-          .maximum(:created_at)
+        month_start = Date.current.beginning_of_month
+
+        @tenant_costs = @tenants.to_h do |tenant|
+          [tenant.tenant_id, (tenant.monthly_reset_date == month_start) ? tenant.monthly_cost_spent : 0]
+        end
+        @tenant_last_executions = @tenants.to_h { |tenant| [tenant.tenant_id, tenant.last_execution_at] }
       end
 
       # Parses and validates sort parameters for tenants list