ruby_llm-agents 1.0.0 → 1.2.0

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

@@ -169,18 +169,33 @@ module RubyLLM
           # Returns chart data as arrays for Highcharts live updates
           # Format: { categories: [...], series: [...], range: ... }
           #
-          # @param range [String] Time range: "today" (hourly), "7d" or "30d" (daily)
-          def activity_chart_json(range: "today")
+          # @param range [String] Time range: "today" (hourly), "7d", "30d", "60d", or "90d" (daily)
+          # @param offset_days [Integer, nil] Optional offset for comparison data (shifts time window back)
+          def activity_chart_json(range: "today", offset_days: nil)
             case range
             when "7d"
-              build_daily_chart_data(7)
+              build_daily_chart_data(7, offset_days: offset_days)
             when "30d"
-              build_daily_chart_data(30)
+              build_daily_chart_data(30, offset_days: offset_days)
+            when "60d"
+              build_daily_chart_data(60, offset_days: offset_days)
+            when "90d"
+              build_daily_chart_data(90, offset_days: offset_days)
             else
-              build_hourly_chart_data
+              build_hourly_chart_data(offset_days: offset_days)
             end
           end
 
+          # Returns chart data for a custom date range
+          # Format: { categories: [...], series: [...], range: ... }
+          #
+          # @param from [Date] Start date (inclusive)
+          # @param to [Date] End date (inclusive)
+          # @return [Hash] Chart data with series arrays
+          def activity_chart_json_for_dates(from:, to:)
+            build_daily_chart_data_for_dates(from, to)
+          end
+
           # Alias for backwards compatibility
           def hourly_activity_chart_json
             activity_chart_json(range: "today")
@@ -191,22 +206,30 @@ module RubyLLM
           # 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
+          #
+          # @param offset_days [Integer, nil] Optional offset for comparison data
+          def build_hourly_chart_data(offset_days: nil)
+            offset = offset_days ? offset_days.days : 0.days
+            reference_time = (Time.current - offset).beginning_of_hour
             start_time = reference_time - 23.hours
 
             # Use database-agnostic aggregation with Ruby post-processing
             results = where(created_at: start_time..(reference_time + 1.hour))
-              .select(:status, :total_cost, :created_at)
+              .select(:status, :total_cost, :duration_ms, :input_tokens, :output_tokens, :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 = []
+            duration_data = []
+            tokens_data = []
             total_success = 0
             total_failed = 0
             total_cost = 0.0
+            total_duration_sum = 0
+            total_duration_count = 0
+            total_tokens = 0
 
             (23.downto(0)).each do |hours_ago|
               bucket_time = (reference_time - hours_ago.hours).beginning_of_hour
@@ -215,23 +238,43 @@ module RubyLLM
               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 }
+              t = rows.sum { |r| (r.input_tokens || 0) + (r.output_tokens || 0) }
+
+              # Average duration for this bucket
+              duration_rows = rows.select { |r| r.duration_ms.to_i > 0 }
+              d = duration_rows.any? ? (duration_rows.sum { |r| r.duration_ms.to_i } / duration_rows.count) : 0
 
               success_data << s
               failed_data << f
               cost_data << c.round(4)
+              duration_data << d.round
+              tokens_data << t
 
               total_success += s
               total_failed += f
               total_cost += c
+              total_tokens += t
+              total_duration_sum += duration_rows.sum { |r| r.duration_ms.to_i }
+              total_duration_count += duration_rows.count
             end
 
+            avg_duration_ms = total_duration_count > 0 ? (total_duration_sum / total_duration_count).round : 0
+
             {
               range: "today",
-              totals: { success: total_success, failed: total_failed, cost: total_cost.round(4) },
+              totals: {
+                success: total_success,
+                failed: total_failed,
+                cost: total_cost.round(4),
+                duration_ms: avg_duration_ms,
+                tokens: total_tokens
+              },
               series: [
                 { name: "Success", data: success_data },
-                { name: "Failed", data: failed_data },
-                { name: "Cost", data: cost_data }
+                { name: "Errors", data: failed_data },
+                { name: "Cost", data: cost_data },
+                { name: "Duration", data: duration_data },
+                { name: "Tokens", data: tokens_data }
               ]
             }
           end
@@ -239,48 +282,155 @@ module RubyLLM
           # 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
+          #
+          # @param days [Integer] Number of days to include
+          # @param offset_days [Integer, nil] Optional offset for comparison data
+          def build_daily_chart_data(days, offset_days: nil)
+            offset = offset_days || 0
+            end_date = Date.current - offset.days
+            start_date = end_date - (days - 1).days
 
             # 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)
+              .select(:status, :total_cost, :duration_ms, :input_tokens, :output_tokens, :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 = []
+            duration_data = []
+            tokens_data = []
             total_success = 0
             total_failed = 0
             total_cost = 0.0
+            total_duration_sum = 0
+            total_duration_count = 0
+            total_tokens = 0
 
-            (days - 1).downto(0).each do |days_ago|
-              date = days_ago.days.ago.to_date
+            (days - 1).downto(0).each do |i|
+              date = end_date - i.days
               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 }
+              t = rows.sum { |r| (r.input_tokens || 0) + (r.output_tokens || 0) }
+
+              # Average duration for this bucket
+              duration_rows = rows.select { |r| r.duration_ms.to_i > 0 }
+              d = duration_rows.any? ? (duration_rows.sum { |r| r.duration_ms.to_i } / duration_rows.count) : 0
 
               success_data << s
               failed_data << f
               cost_data << c.round(4)
+              duration_data << d.round
+              tokens_data << t
 
               total_success += s
               total_failed += f
               total_cost += c
+              total_tokens += t
+              total_duration_sum += duration_rows.sum { |r| r.duration_ms.to_i }
+              total_duration_count += duration_rows.count
             end
 
+            avg_duration_ms = total_duration_count > 0 ? (total_duration_sum / total_duration_count).round : 0
+
             {
               range: "#{days}d",
               days: days,
-              totals: { success: total_success, failed: total_failed, cost: total_cost.round(4) },
+              totals: {
+                success: total_success,
+                failed: total_failed,
+                cost: total_cost.round(4),
+                duration_ms: avg_duration_ms,
+                tokens: total_tokens
+              },
+              series: [
+                { name: "Success", data: success_data },
+                { name: "Errors", data: failed_data },
+                { name: "Cost", data: cost_data },
+                { name: "Duration", data: duration_data },
+                { name: "Tokens", data: tokens_data }
+              ]
+            }
+          end
+
+          # Builds daily chart data for a custom date range
+          # Database-agnostic: works with both PostgreSQL and SQLite
+          #
+          # @param from_date [Date] Start date (inclusive)
+          # @param to_date [Date] End date (inclusive)
+          # @return [Hash] Chart data with series arrays
+          def build_daily_chart_data_for_dates(from_date, to_date)
+            days = (to_date - from_date).to_i + 1
+
+            # Use database-agnostic aggregation with Ruby post-processing
+            results = where(created_at: from_date.beginning_of_day..to_date.end_of_day)
+              .select(:status, :total_cost, :duration_ms, :input_tokens, :output_tokens, :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 = []
+            duration_data = []
+            tokens_data = []
+            total_success = 0
+            total_failed = 0
+            total_cost = 0.0
+            total_duration_sum = 0
+            total_duration_count = 0
+            total_tokens = 0
+
+            (0...days).each do |i|
+              date = from_date + i.days
+              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 }
+              t = rows.sum { |r| (r.input_tokens || 0) + (r.output_tokens || 0) }
+
+              # Average duration for this bucket
+              duration_rows = rows.select { |r| r.duration_ms.to_i > 0 }
+              d = duration_rows.any? ? (duration_rows.sum { |r| r.duration_ms.to_i } / duration_rows.count) : 0
+
+              success_data << s
+              failed_data << f
+              cost_data << c.round(4)
+              duration_data << d.round
+              tokens_data << t
+
+              total_success += s
+              total_failed += f
+              total_cost += c
+              total_tokens += t
+              total_duration_sum += duration_rows.sum { |r| r.duration_ms.to_i }
+              total_duration_count += duration_rows.count
+            end
+
+            avg_duration_ms = total_duration_count > 0 ? (total_duration_sum / total_duration_count).round : 0
+
+            {
+              range: "custom",
+              days: days,
+              from: from_date.to_s,
+              to: to_date.to_s,
+              totals: {
+                success: total_success,
+                failed: total_failed,
+                cost: total_cost.round(4),
+                duration_ms: avg_duration_ms,
+                tokens: total_tokens
+              },
               series: [
                 { name: "Success", data: success_data },
-                { name: "Failed", data: failed_data },
-                { name: "Cost", data: cost_data }
+                { name: "Errors", data: failed_data },
+                { name: "Cost", data: cost_data },
+                { name: "Duration", data: duration_data },
+                { name: "Tokens", data: tokens_data }
               ]
             }
           end

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

@@ -156,37 +156,6 @@ module RubyLLM
 
           # @!endgroup
 
-          # @!group Search Scopes
-
-          # @!method search(query)
-          #   Free-text search across error fields and parameters
-          #   @param query [String] Search query
-          #   @return [ActiveRecord::Relation]
-          scope :search, ->(query) do
-            return all if query.blank?
-
-            sanitized_query = "%#{sanitize_sql_like(query)}%"
-            # Use database-agnostic case-insensitive search
-            # PostgreSQL: ILIKE, SQLite: LIKE with LOWER() + ESCAPE clause
-            if connection.adapter_name.downcase.include?("postgresql")
-              where(
-                "error_class ILIKE :q OR error_message ILIKE :q OR CAST(parameters AS TEXT) ILIKE :q",
-                q: sanitized_query
-              )
-            else
-              # SQLite and other databases need ESCAPE clause for backslash to work
-              sanitized_query_lower = sanitized_query.downcase
-              where(
-                "LOWER(error_class) LIKE :q ESCAPE '\\' OR " \
-                "LOWER(error_message) LIKE :q ESCAPE '\\' OR " \
-                "LOWER(CAST(parameters AS TEXT)) LIKE :q ESCAPE '\\'",
-                q: sanitized_query_lower
-              )
-            end
-          end
-
-          # @!endgroup
-
           # @!group Tracing Scopes
 
           # @!method by_trace(trace_id)

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

@@ -21,27 +21,6 @@ module RubyLLM
           workflow_type.present?
         end
 
-        # Returns whether this is a pipeline workflow
-        #
-        # @return [Boolean] true if workflow_type is "pipeline"
-        def pipeline_workflow?
-          workflow_type == "pipeline"
-        end
-
-        # Returns whether this is a parallel workflow
-        #
-        # @return [Boolean] true if workflow_type is "parallel"
-        def parallel_workflow?
-          workflow_type == "parallel"
-        end
-
-        # Returns whether this is a router workflow
-        #
-        # @return [Boolean] true if workflow_type is "router"
-        def router_workflow?
-          workflow_type == "router"
-        end
-
         # Returns whether this is a root workflow execution (top-level)
         #
         # @return [Boolean] true if this is a workflow with no parent
@@ -134,114 +113,6 @@ module RubyLLM
 
         # @!endgroup
 
-        # @!group Pipeline-specific Methods
-
-        # Returns pipeline steps in order with their status
-        #
-        # @return [Array<Hash>] Array of step hashes with name, status, duration, cost
-        def pipeline_steps_detail
-          return [] unless pipeline_workflow?
-
-          workflow_steps.map do |step|
-            {
-              id: step.id,
-              name: step.workflow_step || step.agent_type.gsub(/Agent$/, ""),
-              agent_type: step.agent_type,
-              status: step.status,
-              duration_ms: step.duration_ms,
-              total_cost: step.total_cost,
-              total_tokens: step.total_tokens,
-              model_id: step.model_id
-            }
-          end
-        end
-
-        # @!endgroup
-
-        # @!group Parallel-specific Methods
-
-        # Returns parallel branches with their status and timing
-        #
-        # @return [Array<Hash>] Array of branch hashes
-        def parallel_branches_detail
-          return [] unless parallel_workflow?
-
-          branches = workflow_steps.to_a
-          return [] if branches.empty?
-
-          # Find min/max for timing comparison
-          min_duration = branches.map { |b| b.duration_ms || 0 }.min
-          max_duration = branches.map { |b| b.duration_ms || 0 }.max
-
-          branches.map do |branch|
-            duration = branch.duration_ms || 0
-            {
-              id: branch.id,
-              name: branch.workflow_step || branch.agent_type.gsub(/Agent$/, ""),
-              agent_type: branch.agent_type,
-              status: branch.status,
-              duration_ms: duration,
-              total_cost: branch.total_cost,
-              total_tokens: branch.total_tokens,
-              model_id: branch.model_id,
-              is_fastest: duration == min_duration && branches.size > 1,
-              is_slowest: duration == max_duration && branches.size > 1 && min_duration != max_duration
-            }
-          end
-        end
-
-        # @!endgroup
-
-        # @!group Router-specific Methods
-
-        # Returns router classification details
-        #
-        # @return [Hash] Classification info including method, model, timing
-        def router_classification_detail
-          return {} unless router_workflow?
-
-          result = if classification_result.is_a?(String)
-                     begin
-                       JSON.parse(classification_result)
-                     rescue JSON::ParserError
-                       {}
-                     end
-                   else
-                     classification_result || {}
-                   end
-
-          {
-            method: result["method"],
-            classifier_model: result["classifier_model"],
-            classification_time_ms: result["classification_time_ms"],
-            routed_to: routed_to,
-            confidence: result["confidence"]
-          }
-        end
-
-        # Returns available routes and which one was chosen
-        #
-        # @return [Hash] Routes info with chosen route highlighted
-        def router_routes_detail
-          return {} unless router_workflow?
-
-          # Get the routed execution (child)
-          routed_child = child_executions.first
-
-          {
-            chosen_route: routed_to,
-            routed_execution: routed_child ? {
-              id: routed_child.id,
-              agent_type: routed_child.agent_type,
-              status: routed_child.status,
-              duration_ms: routed_child.duration_ms,
-              total_cost: routed_child.total_cost
-            } : nil
-          }
-        end
-
-        # @!endgroup
-
         private
 
         # Returns empty aggregate stats hash

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

@@ -239,23 +239,59 @@ module RubyLLM
       # Returns real-time dashboard data for the Now Strip
       #
       # @param range [String] Time range: "today", "7d", or "30d"
-      # @return [Hash] Now strip metrics
+      # @return [Hash] Now strip metrics with period-over-period comparisons
       def self.now_strip_data(range: "today")
-        scope = case range
-                when "7d" then last_n_days(7)
-                when "30d" then last_n_days(30)
-                else today
-                end
-
-        {
+        current_scope = case range
+                        when "7d" then last_n_days(7)
+                        when "30d" then last_n_days(30)
+                        else today
+                        end
+
+        previous_scope = case range
+                         when "7d" then where(created_at: 14.days.ago.beginning_of_day..7.days.ago.beginning_of_day)
+                         when "30d" then where(created_at: 60.days.ago.beginning_of_day..30.days.ago.beginning_of_day)
+                         else yesterday
+                         end
+
+        current = {
           running: running.count,
-          success_today: scope.status_success.count,
-          errors_today: scope.status_error.count,
-          timeouts_today: scope.status_timeout.count,
-          cost_today: scope.sum(:total_cost) || 0,
-          executions_today: scope.count,
-          success_rate: calculate_period_success_rate(scope)
+          success_today: current_scope.status_success.count,
+          errors_today: current_scope.status_error.count,
+          timeouts_today: current_scope.status_timeout.count,
+          cost_today: current_scope.sum(:total_cost) || 0,
+          executions_today: current_scope.count,
+          success_rate: calculate_period_success_rate(current_scope),
+          avg_duration_ms: current_scope.avg_duration&.round || 0,
+          total_tokens: current_scope.total_tokens_sum || 0
+        }
+
+        previous = {
+          success: previous_scope.status_success.count,
+          errors: previous_scope.status_error.count,
+          cost: previous_scope.sum(:total_cost) || 0,
+          avg_duration_ms: previous_scope.avg_duration&.round || 0,
+          total_tokens: previous_scope.total_tokens_sum || 0
         }
+
+        current.merge(
+          comparisons: {
+            success_change: pct_change(previous[:success], current[:success_today]),
+            errors_change: pct_change(previous[:errors], current[:errors_today]),
+            cost_change: pct_change(previous[:cost], current[:cost_today]),
+            duration_change: pct_change(previous[:avg_duration_ms], current[:avg_duration_ms]),
+            tokens_change: pct_change(previous[:total_tokens], current[:total_tokens])
+          }
+        )
+      end
+
+      # Calculates percentage change between old and new values
+      #
+      # @param old_val [Numeric, nil] Previous period value
+      # @param new_val [Numeric] Current period value
+      # @return [Float, nil] Percentage change or nil if old_val is nil/zero
+      def self.pct_change(old_val, new_val)
+        return nil if old_val.nil? || old_val.zero?
+        ((new_val - old_val).to_f / old_val * 100).round(1)
       end
 
       # Calculates success rate for a given scope