ruby_llm-agents 0.3.3 → 0.3.5

data/app/controllers/concerns/ruby_llm/agents/filterable.rb

@@ -74,7 +74,11 @@ module RubyLLM
       # @param days [Integer, nil] Number of days to filter by
       # @return [ActiveRecord::Relation] Filtered scope
       def apply_time_filter(scope, days)
-        days.present? && days.positive? ? scope.where("created_at >= ?", days.days.ago) : scope
+        return scope unless days.present? && days.positive?
+
+        # Qualify column name to avoid ambiguity when joins are present
+        table_name = scope.model.table_name
+        scope.where("#{table_name}.created_at >= ?", days.days.ago)
       end
     end
   end

data/app/controllers/concerns/ruby_llm/agents/paginatable.rb

@@ -33,7 +33,8 @@ module RubyLLM
         per_page = RubyLLM::Agents.configuration.per_page
         offset = (page - 1) * per_page
 
-        scope = scope.order(created_at: :desc) if ordered
+        # Qualify column name to avoid ambiguity when joins are present
+        scope = scope.order("#{scope.model.table_name}.created_at DESC") if ordered
         total_count = scope.count
 
         {

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

@@ -20,14 +20,33 @@ module RubyLLM
       #
       # Uses AgentRegistry to discover agents from both file system
       # and execution history, ensuring deleted agents with history
-      # are still visible.
+      # are still visible. Separates agents and workflows for tabbed display.
       #
       # @return [void]
       def index
-        @agents = AgentRegistry.all_with_details
+        all_items = AgentRegistry.all_with_details
+
+        # Separate agents and workflows
+        @agents = all_items.reject { |a| a[:is_workflow] }
+        @workflows = all_items.select { |a| a[:is_workflow] }
+
+        # Group workflows by type for sub-tabs
+        @workflows_by_type = {
+          pipeline: @workflows.select { |w| w[:workflow_type] == "pipeline" },
+          parallel: @workflows.select { |w| w[:workflow_type] == "parallel" },
+          router: @workflows.select { |w| w[:workflow_type] == "router" }
+        }
+
+        # Counts for tab badges
+        @agent_count = @agents.size
+        @workflow_count = @workflows.size
       rescue StandardError => e
         Rails.logger.error("[RubyLLM::Agents] Error loading agents: #{e.message}")
         @agents = []
+        @workflows = []
+        @workflows_by_type = { pipeline: [], parallel: [], router: [] }
+        @agent_count = 0
+        @workflow_count = 0
         flash.now[:alert] = "Error loading agents list"
       end
 

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

@@ -14,25 +14,121 @@ module RubyLLM
       # Renders the main dashboard view
       #
       # Loads now strip data, critical alerts, hourly activity,
-      # and recent executions for real-time monitoring.
+      # recent executions, agent comparison, and top errors.
       #
       # @return [void]
       def index
-        @now_strip = Execution.now_strip_data
-        @critical_alerts = load_critical_alerts
-        @hourly_activity = Execution.hourly_activity_chart
-        @recent_executions = Execution.recent(10)
+        @selected_range = params[:range].presence || "today"
+        @days = range_to_days(@selected_range)
+        base_scope = tenant_scoped_executions
+        @now_strip = base_scope.now_strip_data(range: @selected_range)
+        @critical_alerts = load_critical_alerts(base_scope)
+        @recent_executions = base_scope.recent(10)
+        @agent_stats = build_agent_comparison(base_scope)
+        @top_errors = build_top_errors(base_scope)
+        @tenant_budget = load_tenant_budget(base_scope)
       end
 
       # Returns chart data as JSON for live updates
       #
-      # @return [JSON] Chart data with categories and series
+      # @param range [String] Time range: "today", "7d", or "30d"
+      # @return [JSON] Chart data with series
       def chart_data
-        render json: Execution.hourly_activity_chart_json
+        range = params[:range].presence || "today"
+        render json: tenant_scoped_executions.activity_chart_json(range: range)
       end
 
       private
 
+      # Converts range parameter to number of days
+      #
+      # @param range [String] Range parameter (today, 7d, 30d)
+      # @return [Integer] Number of days
+      def range_to_days(range)
+        case range
+        when "today" then 1
+        when "7d" then 7
+        when "30d" then 30
+        else 1
+        end
+      end
+
+      # Builds per-agent comparison statistics
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
+      # @return [Array<Hash>] Array of all stats sorted by cost descending
+      def build_agent_comparison(base_scope = Execution)
+        scope = base_scope.last_n_days(@days)
+        agent_types = scope.distinct.pluck(:agent_type)
+
+        all_stats = agent_types.map do |agent_type|
+          agent_scope = scope.where(agent_type: agent_type)
+          count = agent_scope.count
+          total_cost = agent_scope.sum(:total_cost) || 0
+          successful = agent_scope.successful.count
+
+          # Detect if this is a workflow
+          agent_class = AgentRegistry.find(agent_type)
+          is_workflow = agent_class&.ancestors&.any? { |a| a.name&.include?("Workflow") }
+          workflow_type = is_workflow ? detect_workflow_type(agent_class) : nil
+
+          {
+            agent_type: agent_type,
+            executions: count,
+            total_cost: total_cost,
+            avg_cost: count > 0 ? (total_cost / count).round(6) : 0,
+            avg_duration_ms: agent_scope.average(:duration_ms)&.round || 0,
+            success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0,
+            is_workflow: is_workflow,
+            workflow_type: workflow_type
+          }
+        end.sort_by { |a| -(a[:total_cost] || 0) }
+
+        # Split into agents and workflows for tabbed display
+        @workflow_stats = all_stats.select { |a| a[:is_workflow] }
+        all_stats.reject { |a| a[:is_workflow] }
+      end
+
+      # Detects workflow type from class hierarchy
+      #
+      # @param agent_class [Class] The agent class
+      # @return [String, nil] "pipeline", "parallel", "router", or nil
+      def detect_workflow_type(agent_class)
+        return nil unless agent_class
+
+        ancestors = agent_class.ancestors.map { |a| a.name.to_s }
+
+        if ancestors.include?("RubyLLM::Agents::Workflow::Pipeline")
+          "pipeline"
+        elsif ancestors.include?("RubyLLM::Agents::Workflow::Parallel")
+          "parallel"
+        elsif ancestors.include?("RubyLLM::Agents::Workflow::Router")
+          "router"
+        end
+      end
+
+      # Builds top errors list
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
+      # @return [Array<Hash>] Top 5 error classes with counts
+      def build_top_errors(base_scope = Execution)
+        scope = base_scope.last_n_days(@days).where(status: "error")
+        total_errors = scope.count
+
+        scope.group(:error_class)
+             .select("error_class, COUNT(*) as count, MAX(created_at) as last_seen")
+             .order("count DESC")
+             .limit(5)
+             .map do |row|
+          {
+            error_class: row.error_class || "Unknown Error",
+            count: row.count,
+            percentage: total_errors > 0 ? (row.count.to_f / total_errors * 100).round(1) : 0,
+            last_seen: row.last_seen
+          }
+        end
+      end
+
       # Fetches cached daily statistics for the dashboard
       #
       # Results are cached for 1 minute to reduce database load while
@@ -123,6 +219,37 @@ module RubyLLM
         []
       end
 
+      # Loads tenant budget info for the current tenant
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope for usage calculation
+      # @return [Hash, nil] Tenant budget data with usage info, or nil if not applicable
+      def load_tenant_budget(base_scope)
+        return nil unless tenant_filter_enabled? && current_tenant_id.present?
+        return nil unless TenantBudget.table_exists?
+
+        budget = TenantBudget.for_tenant(current_tenant_id)
+        return nil unless budget
+
+        # Calculate current usage
+        today_scope = base_scope.where("created_at >= ?", Time.current.beginning_of_day)
+        month_scope = base_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
+
+        {
+          tenant_id: current_tenant_id,
+          daily_limit: budget.effective_daily_limit,
+          monthly_limit: budget.effective_monthly_limit,
+          daily_spend: daily_spend,
+          monthly_spend: monthly_spend,
+          daily_percentage: budget.effective_daily_limit.to_f > 0 ? (daily_spend / budget.effective_daily_limit * 100).round(1) : 0,
+          monthly_percentage: budget.effective_monthly_limit.to_f > 0 ? (monthly_spend / budget.effective_monthly_limit * 100).round(1) : 0,
+          enforcement: budget.effective_enforcement,
+          per_agent_daily: budget.per_agent_daily || {}
+        }
+      end
+
       # Loads recent alerts from cache
       #
       # @return [Array<Hash>] Array of recent alert events
@@ -140,8 +267,9 @@ module RubyLLM
       # Combines open circuit breakers, budget breaches, and error spikes
       # into a single prioritized list (max 3 items).
       #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
       # @return [Array<Hash>] Critical alerts with type and data
-      def load_critical_alerts
+      def load_critical_alerts(base_scope = Execution)
         alerts = []
 
         # Open circuit breakers
@@ -177,7 +305,7 @@ module RubyLLM
         end
 
         # Error spike detection (>5 errors in last 15 minutes)
-        error_count_15m = Execution.status_error.where("created_at > ?", 15.minutes.ago).count
+        error_count_15m = base_scope.status_error.where("created_at > ?", 15.minutes.ago).count
         if error_count_15m >= 5
           alerts << { type: :error_spike, data: { count: error_count_15m } }
         end

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

@@ -155,32 +155,53 @@ module RubyLLM
       # Loads available options for filter dropdowns
       #
       # Populates @agent_types with all agent types that have executions,
-      # @model_ids with all distinct models used, and @statuses with all
-      # possible status values.
+      # @model_ids with all distinct models used, @workflow_types with
+      # workflow patterns used, and @statuses with all possible status values.
       #
       # @return [void]
       def load_filter_options
         @agent_types = available_agent_types
         @model_ids = available_model_ids
+        @workflow_types = available_workflow_types
         @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 ||= Execution.distinct.pluck(:agent_type)
+        @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 ||= Execution.where.not(model_id: nil).distinct.pluck(:model_id).sort
+        @available_model_ids ||= tenant_scoped_executions.where.not(model_id: nil).distinct.pluck(:model_id).sort
+      end
+
+      # Returns distinct workflow types from execution history
+      #
+      # Memoized to avoid duplicate queries within a request.
+      # Returns empty array if workflow_type column doesn't exist yet.
+      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
+      #
+      # @return [Array<String>] Workflow types (pipeline, parallel, router)
+      def available_workflow_types
+        return @available_workflow_types if defined?(@available_workflow_types)
+
+        @available_workflow_types = if Execution.column_names.include?("workflow_type")
+                                      tenant_scoped_executions.where.not(workflow_type: [nil, ""])
+                                                              .distinct.pluck(:workflow_type).sort
+                                    else
+                                      []
+                                    end
       end
 
       # Loads paginated executions and associated statistics
@@ -215,7 +236,7 @@ module RubyLLM
       #
       # @return [ActiveRecord::Relation] Filtered execution scope
       def filtered_executions
-        scope = Execution.all
+        scope = tenant_scoped_executions
 
         # Apply search filter
         scope = scope.search(params[:q]) if params[:q].present?
@@ -244,8 +265,65 @@ module RubyLLM
         model_ids = parse_array_param(:model_ids)
         scope = scope.where(model_id: model_ids) if model_ids.any?
 
+        # Apply workflow type filter (only if column exists)
+        if Execution.column_names.include?("workflow_type")
+          workflow_types = parse_array_param(:workflow_types)
+          if workflow_types.any?
+            includes_single = workflow_types.include?("single")
+            other_types = workflow_types - ["single"]
+
+            if includes_single && other_types.any?
+              # Include both single (null workflow_type) and specific workflow types
+              scope = scope.where(workflow_type: [nil, ""] + other_types)
+            elsif includes_single
+              # Only single executions (non-workflow)
+              scope = scope.where(workflow_type: [nil, ""])
+            else
+              # Only specific workflow types
+              scope = scope.where(workflow_type: workflow_types)
+            end
+          end
+        end
+
+        # Apply execution type tab filter (agents vs workflows)
+        scope = apply_execution_type_filter(scope)
+
+        # Only show root executions (not workflow children) - children are nested under parents
+        scope = scope.where(parent_execution_id: nil)
+
+        # Eager load children for workflow grouping
+        scope = scope.includes(:child_executions)
+
         scope
       end
+
+      # Applies execution type tab filter (all, agents, workflows)
+      #
+      # @param scope [ActiveRecord::Relation] The current scope
+      # @return [ActiveRecord::Relation] Filtered scope
+      def apply_execution_type_filter(scope)
+        return scope unless Execution.column_names.include?("workflow_type")
+
+        execution_type = params[:execution_type]
+        case execution_type
+        when "agents"
+          # Only show executions where workflow_type is null/empty (regular agents)
+          scope.where(workflow_type: [nil, ""])
+        when "workflows"
+          # Only show executions with a workflow_type
+          workflow_scope = scope.where.not(workflow_type: [nil, ""])
+
+          # Apply workflow type sub-filter if specified
+          workflow_type_tab = params[:workflow_type_tab]
+          if workflow_type_tab.present? && %w[pipeline parallel router].include?(workflow_type_tab)
+            workflow_scope = workflow_scope.where(workflow_type: workflow_type_tab)
+          end
+
+          workflow_scope
+        else
+          scope
+        end
+      end
     end
   end
 end

data/app/models/ruby_llm/agents/execution/analytics.rb

@@ -167,35 +167,126 @@ module RubyLLM
           end
 
           # Returns chart data as arrays for Highcharts live updates
-          # Format: { categories: [...], series: [...] }
+          # Format: { categories: [...], series: [...], range: ... }
+          #
+          # @param range [String] Time range: "today" (hourly), "7d" or "30d" (daily)
+          def activity_chart_json(range: "today")
+            case range
+            when "7d"
+              build_daily_chart_data(7)
+            when "30d"
+              build_daily_chart_data(30)
+            else
+              build_hourly_chart_data
+            end
+          end
+
+          # Alias for backwards compatibility
           def hourly_activity_chart_json
-            # Always use current time as reference so chart shows "now" on the right
+            activity_chart_json(range: "today")
+          end
+
+          private
+
+          # Builds hourly chart data for last 24 hours
+          # Optimized: Single GROUP BY query instead of 72 individual queries
+          # Database-agnostic: works with both PostgreSQL and SQLite
+          def build_hourly_chart_data
             reference_time = Time.current.beginning_of_hour
+            start_time = reference_time - 23.hours
 
-            categories = []
+            # Use database-agnostic aggregation with Ruby post-processing
+            results = where(created_at: start_time..(reference_time + 1.hour))
+              .select(:status, :total_cost, :created_at)
+              .group_by { |r| r.created_at.beginning_of_hour }
+
+            # Build arrays for all 24 hours (fill missing with zeros)
             success_data = []
             failed_data = []
+            cost_data = []
+            total_success = 0
+            total_failed = 0
+            total_cost = 0.0
 
-            # Create entries for the last 24 hours ending at current hour
             (23.downto(0)).each do |hours_ago|
-              start_time = reference_time - hours_ago.hours
-              end_time = start_time + 1.hour
-              categories << start_time.in_time_zone.strftime("%H:%M")
+              bucket_time = (reference_time - hours_ago.hours).beginning_of_hour
+              rows = results[bucket_time] || []
 
-              hour_scope = where(created_at: start_time...end_time)
-              success_data << hour_scope.successful.count
-              failed_data << hour_scope.failed.count
+              s = rows.count { |r| r.status == "success" }
+              f = rows.count { |r| r.status.in?(%w[error timeout]) }
+              c = rows.sum { |r| r.total_cost.to_f }
+
+              success_data << s
+              failed_data << f
+              cost_data << c.round(4)
+
+              total_success += s
+              total_failed += f
+              total_cost += c
             end
 
             {
-              categories: categories,
+              range: "today",
+              totals: { success: total_success, failed: total_failed, cost: total_cost.round(4) },
               series: [
                 { name: "Success", data: success_data },
-                { name: "Failed", data: failed_data }
+                { name: "Failed", data: failed_data },
+                { name: "Cost", data: cost_data }
               ]
             }
           end
 
+          # Builds daily chart data for specified number of days
+          # Optimized: Single query instead of 3*days individual queries
+          # Database-agnostic: works with both PostgreSQL and SQLite
+          def build_daily_chart_data(days)
+            end_date = Date.current
+            start_date = (days - 1).days.ago.to_date
+
+            # Use database-agnostic aggregation with Ruby post-processing
+            results = where(created_at: start_date.beginning_of_day..end_date.end_of_day)
+              .select(:status, :total_cost, :created_at)
+              .group_by { |r| r.created_at.to_date }
+
+            # Build arrays for all days (fill missing with zeros)
+            success_data = []
+            failed_data = []
+            cost_data = []
+            total_success = 0
+            total_failed = 0
+            total_cost = 0.0
+
+            (days - 1).downto(0).each do |days_ago|
+              date = days_ago.days.ago.to_date
+              rows = results[date] || []
+
+              s = rows.count { |r| r.status == "success" }
+              f = rows.count { |r| r.status.in?(%w[error timeout]) }
+              c = rows.sum { |r| r.total_cost.to_f }
+
+              success_data << s
+              failed_data << f
+              cost_data << c.round(4)
+
+              total_success += s
+              total_failed += f
+              total_cost += c
+            end
+
+            {
+              range: "#{days}d",
+              days: days,
+              totals: { success: total_success, failed: total_failed, cost: total_cost.round(4) },
+              series: [
+                { name: "Success", data: success_data },
+                { name: "Failed", data: failed_data },
+                { name: "Cost", data: cost_data }
+              ]
+            }
+          end
+
+          public
+
           # Builds the hourly activity data structure
           # Shows the last 24 hours with current hour on the right
           #

data/app/models/ruby_llm/agents/execution/scopes.rb

@@ -47,6 +47,31 @@ module RubyLLM
 
           # @!endgroup
 
+          # @!group Tenant Scopes
+
+          # @!method by_tenant(tenant_id)
+          #   Filters to a specific tenant
+          #   @param tenant_id [String] The tenant identifier
+          #   @return [ActiveRecord::Relation]
+
+          # @!method for_current_tenant
+          #   Filters to the current tenant from the resolver
+          #   @return [ActiveRecord::Relation]
+          scope :by_tenant, ->(tenant_id) { where(tenant_id: tenant_id) }
+          scope :without_tenant, -> { where(tenant_id: nil) }
+          scope :with_tenant, -> { where.not(tenant_id: nil) }
+          scope :for_current_tenant, -> {
+            config = RubyLLM::Agents.configuration
+            if config.multi_tenancy_enabled?
+              tenant_id = config.tenant_resolver&.call
+              tenant_id ? where(tenant_id: tenant_id) : all
+            else
+              all
+            end
+          }
+
+          # @!endgroup
+
           # @!group Agent-based Scopes
 
           # @!method by_agent(agent_type)