ruby_llm-agents 3.15.1 → 3.16.0

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

@@ -78,24 +78,142 @@ module RubyLLM
           # @param period [Symbol] Time scope (:today, :this_week, :this_month, :all_time)
           # @return [Hash] Statistics including count, costs, tokens, duration, rates
           def stats_for(agent_type, period: :today)
-            scope = by_agent(agent_type).public_send(period)
-            count = scope.count
-            total_cost = scope.total_cost_sum || 0
+            {agent_type: agent_type, period: period}
+              .merge(by_agent(agent_type).public_send(period).usage_summary)
+          end
+
+          # Usage and reliability figures for the current scope, in one query
+          #
+          # @example An agent's last 30 days
+          #   Execution.by_agent("SearchAgent").last_n_days(30).usage_summary
+          #
+          # @return [Hash] :count, :total_cost, :avg_cost, :total_tokens,
+          #   :avg_tokens, :avg_duration_ms, :success_rate, :error_rate,
+          #   :cache_hit_rate, :streaming_rate
+          def usage_summary
+            count, cost, tokens, avg_tok, avg_dur, successful, failed, cache_hits, streamed = pick(
+              Arel.sql("COUNT(*)"),
+              Arel.sql("COALESCE(SUM(total_cost), 0)"),
+              Arel.sql("COALESCE(SUM(total_tokens), 0)"),
+              Arel.sql("AVG(total_tokens)"),
+              Arel.sql("AVG(duration_ms)"),
+              Arel.sql("SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END)"),
+              Arel.sql("SUM(CASE WHEN status IN ('error', 'timeout') THEN 1 ELSE 0 END)"),
+              Arel.sql("SUM(CASE WHEN #{true_condition("cache_hit")} THEN 1 ELSE 0 END)"),
+              Arel.sql("SUM(CASE WHEN #{true_condition("streaming")} THEN 1 ELSE 0 END)")
+            )
+
+            count = count.to_i
+            total_cost = (cost || 0).to_d.round(6)
+            percent = ->(part, digits) { (count > 0) ? (part.to_f / count * 100).round(digits) : 0.0 }
 
             {
-              agent_type: agent_type,
-              period: period,
               count: count,
               total_cost: total_cost,
               avg_cost: (count > 0) ? (total_cost / count).round(6) : 0,
-              total_tokens: scope.total_tokens_sum || 0,
-              avg_tokens: scope.avg_tokens&.round || 0,
-              avg_duration_ms: scope.avg_duration&.round || 0,
-              success_rate: calculate_success_rate(scope),
-              error_rate: calculate_error_rate(scope)
+              total_tokens: tokens.to_i,
+              avg_tokens: avg_tok&.round || 0,
+              avg_duration_ms: avg_dur&.round || 0,
+              success_rate: percent.call(successful, 2),
+              error_rate: percent.call(failed, 2),
+              cache_hit_rate: percent.call(cache_hits, 1),
+              streaming_rate: percent.call(streamed, 1)
             }
           end
 
+          # Count, cost and token totals for the current scope in one query
+          #
+          # @return [Hash] :total_count, :total_cost (BigDecimal), :total_tokens
+          def totals
+            count, cost, tokens = pick(
+              Arel.sql("COUNT(*)"),
+              Arel.sql("COALESCE(SUM(total_cost), 0)"),
+              Arel.sql("COALESCE(SUM(total_tokens), 0)")
+            )
+
+            {total_count: count.to_i, total_cost: (cost || 0).to_d.round(6), total_tokens: tokens.to_i}
+          end
+
+          # Everything the dashboard shows about the current scope, from one scan
+          #
+          # Reads the scope once, grouped by agent, model, status and error
+          # class. The returned {Breakdown} derives totals, per-agent and
+          # per-model stats, top errors, error cost and cache savings from
+          # those groups, so a page that shows all of them costs one pass over
+          # the time window instead of one per section.
+          #
+          # @return [Execution::Breakdown]
+          def breakdown
+            # Spend belongs to the model that actually ran, not the one that
+            # was configured — a fallback's cost must not be billed to the
+            # primary. Older rows predate chosen_model_id.
+            billed_model = Arel.sql("COALESCE(chosen_model_id, model_id)")
+            hit = cache_hit_condition
+
+            Breakdown.new(group(:agent_type, :model_id, billed_model, :status, :error_class).pluck(
+              :agent_type, :model_id, billed_model, :status, :error_class,
+              Arel.sql("COUNT(*)"),
+              Arel.sql("COALESCE(SUM(total_cost), 0)"),
+              Arel.sql("COALESCE(SUM(total_tokens), 0)"),
+              Arel.sql("COALESCE(SUM(duration_ms), 0)"),
+              Arel.sql("COUNT(duration_ms)"),
+              Arel.sql("SUM(CASE WHEN #{hit} THEN 1 ELSE 0 END)"),
+              Arel.sql("COALESCE(SUM(CASE WHEN #{hit} THEN 0 ELSE total_cost END), 0)"),
+              Arel.sql("MAX(created_at)")
+            ))
+          end
+
+          # Runs a block with the database's statement timeout lowered
+          #
+          # Dashboard queries aggregate over whatever window the user picked,
+          # so on a large table a wide window can run for minutes — long after
+          # the web server has given up on the request, and with the database
+          # still working on it. Under a statement timeout the database
+          # cancels the query instead and the block raises
+          # ActiveRecord::QueryCanceled.
+          #
+          # PostgreSQL only; elsewhere the block simply runs. A stricter
+          # timeout already in force is left alone. Uses SET LOCAL inside a
+          # (sub)transaction, so the setting never outlives the block and is
+          # safe behind a transaction-pooling proxy.
+          #
+          # @param seconds [Numeric, nil] Timeout; nil runs the block unguarded
+          # @yield Queries to guard. They must run inside the block — load
+          #   relations before returning them.
+          # @return [Object] The block's value
+          # @raise [ActiveRecord::QueryCanceled] When a statement is cancelled
+          def with_statement_timeout(seconds)
+            return yield unless seconds && connection.adapter_name.downcase.include?("postg")
+
+            transaction(requires_new: true) do
+              current = connection.select_value("SELECT setting FROM pg_settings WHERE name = 'statement_timeout'").to_i
+              wanted = (seconds * 1000).ceil
+              next yield if current.positive? && current <= wanted
+
+              connection.execute("SET LOCAL statement_timeout = #{wanted}")
+              result = yield
+              # Releasing a savepoint keeps its SET LOCAL, so restore by hand;
+              # after a cancellation the rollback restores it instead.
+              connection.execute("SET LOCAL statement_timeout = #{current}")
+              result
+            end
+          end
+
+          # Runs a block of queries that the page can live without
+          #
+          # For figures that are nice to have next to the real content (the
+          # totals strip above a list, say): if the database cannot answer
+          # within the timeout the caller gets nil and renders a placeholder,
+          # rather than the whole page waiting on an aggregate.
+          #
+          # @param timeout [Numeric] Seconds to allow (PostgreSQL only)
+          # @return [Object, nil] The block's value, or nil if it was cancelled
+          def best_effort(timeout:, &block)
+            with_statement_timeout(timeout, &block)
+          rescue ::ActiveRecord::QueryCanceled
+            nil
+          end
+
           # Compares performance between two agent versions
           # Analyzes trends over a time period
           #
@@ -470,36 +588,33 @@ module RubyLLM
           #
           # @return [Float] Percentage of executions that were cache hits (0.0-100.0)
           def cache_hit_rate
-            total = count
-            return 0.0 if total.zero?
-
-            (cached.count.to_f / total * 100).round(1)
+            boolean_rate("cache_hit")
           end
 
           # Streaming execution rate percentage
           #
           # @return [Float] Percentage of executions that used streaming (0.0-100.0)
           def streaming_rate
-            total = count
-            return 0.0 if total.zero?
-
-            (streaming.count.to_f / total * 100).round(1)
+            boolean_rate("streaming")
           end
 
           # Average time to first token for streaming executions
           #
-          # time_to_first_token_ms is stored in metadata JSON, so we use
-          # Ruby-level calculation instead of SQL aggregation.
+          # time_to_first_token_ms lives in the metadata JSON column, so the
+          # average is computed from a JSON extract in SQL rather than by
+          # loading every streaming execution's metadata into Ruby.
           #
           # @return [Integer, nil] Average TTFT in milliseconds, or nil if no data
           def avg_time_to_first_token
-            ttft_values = streaming
-              .where("metadata IS NOT NULL")
-              .pluck(:metadata)
-              .filter_map { |m| m&.dig("time_to_first_token_ms") }
-            return nil if ttft_values.empty?
+            ttft = if connection.adapter_name.downcase.include?("sqlite")
+              "json_extract(metadata, '$.time_to_first_token_ms')"
+            else
+              "(metadata->>'time_to_first_token_ms')::numeric"
+            end
 
-            (ttft_values.sum.to_f / ttft_values.size).round(0)
+            streaming.metadata_present("time_to_first_token_ms")
+              .pick(Arel.sql("AVG(#{ttft})"))
+              &.round
           end
 
           # Finish reason distribution
@@ -529,47 +644,11 @@ module RubyLLM
           end
 
           # Builds per-model statistics for model comparison
-          # Optimized: Single SQL GROUP BY with conditional aggregation
           #
           # @param scope [ActiveRecord::Relation] Pre-filtered scope
           # @return [Array<Hash>] Model stats sorted by total cost descending
           def model_stats(scope: all)
-            # Attribute spend to the model that actually ran, not the one that
-            # was configured — otherwise a fallback's cost is billed to the
-            # primary in the comparison table. Older rows predate
-            # chosen_model_id, so fall back to model_id for those.
-            billed_model = Arel.sql("COALESCE(chosen_model_id, model_id)")
-
-            rows = scope.where.not(model_id: nil)
-              .select(
-                Arel.sql("#{billed_model} AS billed_model_id"),
-                Arel.sql("COUNT(*) AS exec_count"),
-                Arel.sql("COALESCE(SUM(total_cost), 0) AS sum_cost"),
-                Arel.sql("COALESCE(SUM(total_tokens), 0) AS sum_tokens"),
-                Arel.sql("AVG(duration_ms) AS avg_dur"),
-                Arel.sql("SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) AS success_cnt")
-              )
-              .group(billed_model)
-
-            total_cost = rows.sum { |r| r["sum_cost"].to_f }
-
-            rows.map do |row|
-              count = row["exec_count"].to_i
-              model_cost = row["sum_cost"].to_f
-              model_tokens = row["sum_tokens"].to_i
-              successful = row["success_cnt"].to_i
-
-              {
-                model_id: row["billed_model_id"],
-                executions: count,
-                total_cost: model_cost,
-                total_tokens: model_tokens,
-                avg_duration_ms: row["avg_dur"].to_i,
-                success_rate: (count > 0) ? (successful.to_f / count * 100).round(1) : 0,
-                cost_per_1k_tokens: (model_tokens > 0) ? (model_cost / model_tokens * 1000).round(4) : 0,
-                cost_percentage: (total_cost > 0) ? (model_cost / total_cost * 100).round(1) : 0
-              }
-            end.sort_by { |m| -(m[:total_cost] || 0) }
+            scope.breakdown.model_stats
           end
 
           # Builds top errors list from error executions
@@ -578,87 +657,23 @@ module RubyLLM
           # @param limit [Integer] Max errors to return
           # @return [Array<Hash>] Top error classes with counts
           def top_errors(scope: all, limit: 5)
-            error_scope = scope.where(status: "error")
-            total_errors = error_scope.count
-
-            error_scope.group(:error_class)
-              .select("error_class, COUNT(*) as count, MAX(created_at) as last_seen")
-              .order("count DESC")
-              .limit(limit)
-              .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
+            scope.breakdown.top_errors(limit: limit)
           end
 
           # Builds cache savings statistics
-          # Optimized: Single SQL query with conditional aggregation
           #
           # @param scope [ActiveRecord::Relation] Pre-filtered scope
           # @return [Hash] Cache savings data
           def cache_savings(scope: all)
-            cond = cache_hit_condition
-            total_count, cache_count, miss_count, miss_cost = scope.pick(
-              Arel.sql("COUNT(*)"),
-              Arel.sql("SUM(CASE WHEN #{cond} THEN 1 ELSE 0 END)"),
-              Arel.sql("SUM(CASE WHEN #{cond} THEN 0 ELSE 1 END)"),
-              Arel.sql("COALESCE(SUM(CASE WHEN #{cond} THEN 0 ELSE total_cost END), 0)")
-            )
-
-            total_count = total_count.to_i
-            cache_count = cache_count.to_i
-            miss_count = miss_count.to_i
-
-            return {count: 0, estimated_savings: 0, hit_rate: 0, total_executions: 0} if total_count.zero?
-
-            # Savings are the cost AVOIDED, not the cost recorded: a cache hit
-            # makes no API call, so its own total_cost is always 0 and summing
-            # those rows reported $0.00 saved forever. Estimate each hit at the
-            # mean cost of the misses in this same scope.
-            #
-            # ponytail: scope-wide mean, not per-agent. Group by agent_type if
-            # a mixed dashboard scope ever skews this enough to matter.
-            avg_miss_cost = miss_count.positive? ? (miss_cost.to_f / miss_count) : 0.0
-
-            {
-              count: cache_count,
-              estimated_savings: (cache_count * avg_miss_cost).round(6),
-              hit_rate: (cache_count.to_f / total_count * 100).round(1),
-              total_executions: total_count
-            }
+            scope.breakdown.cache_savings
           end
 
           # Batch fetches execution stats grouped by agent type
-          # Optimized: Single SQL GROUP BY with conditional aggregation
           #
           # @param scope [ActiveRecord::Relation] Pre-filtered scope
           # @return [Hash<String, Hash>] Agent type => stats hash
           def batch_agent_stats(scope: all)
-            rows = scope.select(
-              :agent_type,
-              Arel.sql("COUNT(*) AS exec_count"),
-              Arel.sql("COALESCE(SUM(total_cost), 0) AS sum_cost"),
-              Arel.sql("AVG(duration_ms) AS avg_dur"),
-              Arel.sql("SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) AS success_cnt")
-            ).group(:agent_type)
-
-            rows.each_with_object({}) do |row, hash|
-              count = row["exec_count"].to_i
-              total_cost = row["sum_cost"].to_f
-              successful = row["success_cnt"].to_i
-
-              hash[row.agent_type] = {
-                count: count,
-                total_cost: total_cost,
-                avg_cost: (count > 0) ? (total_cost / count).round(6) : 0,
-                avg_duration_ms: row["avg_dur"].to_i,
-                success_rate: (count > 0) ? (successful.to_f / count * 100).round(1) : 0
-              }
-            end
+            scope.breakdown.agent_stats
           end
 
           # Cached daily statistics for dashboard
@@ -790,16 +805,42 @@ module RubyLLM
 
           # SQL condition for boolean cache_hit column
           #
+          # @return [String] SQL condition fragment
+          def cache_hit_condition
+            true_condition("cache_hit")
+          end
+
+          # SQL condition for a boolean column being true
+          #
           # SQLite stores booleans as 1/0, PostgreSQL as TRUE/FALSE.
           #
+          # @param column [String] Column name (internal literal, never user input)
           # @return [String] SQL condition fragment
-          def cache_hit_condition
+          def true_condition(column)
             if connection.adapter_name.downcase.include?("sqlite")
-              "cache_hit = 1"
+              "#{column} = 1"
             else
-              "cache_hit = TRUE"
+              "#{column} = TRUE"
             end
           end
+
+          # Percentage of the current scope where a boolean column is true
+          #
+          # One query (count plus conditional sum) rather than a count of the
+          # scope followed by a count of the filtered scope.
+          #
+          # @param column [String] Column name (internal literal, never user input)
+          # @return [Float] 0.0-100.0
+          def boolean_rate(column)
+            total, hits = pick(
+              Arel.sql("COUNT(*)"),
+              Arel.sql("SUM(CASE WHEN #{true_condition(column)} THEN 1 ELSE 0 END)")
+            )
+            total = total.to_i
+            return 0.0 if total.zero?
+
+            (hits.to_f / total * 100).round(1)
+          end
         end
       end
     end

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

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class Execution
+      # Every dashboard figure for a set of executions, from one scan
+      #
+      # The dashboard and analytics pages each show half a dozen sections over
+      # the same time window: totals, per-agent stats, per-model stats, top
+      # errors, cache savings, error cost. Computed separately, that is one
+      # pass over the window per section — and on a table with millions of
+      # executions each pass takes seconds. A Breakdown reads the window once,
+      # grouped by the few low-cardinality columns the sections slice on, and
+      # derives each section from those groups in Ruby.
+      #
+      # @example
+      #   breakdown = Execution.last_n_days(30).breakdown
+      #   breakdown.totals       #=> { total: 1200, cost: 4.2, success_rate: 97.1, ... }
+      #   breakdown.model_stats  #=> [{ model_id: "gpt-4o", executions: 800, ... }]
+      #   breakdown.top_errors   #=> [{ error_class: "Timeout::Error", count: 12, ... }]
+      #
+      # @see Execution::Analytics::ClassMethods#breakdown
+      # @api public
+      class Breakdown
+        Group = Struct.new(
+          :agent_type, :model_id, :billed_model_id, :status, :error_class,
+          :count, :cost, :tokens, :duration_sum, :duration_count,
+          :cache_hits, :miss_cost, :last_seen
+        )
+
+        # Raw grouped rows, as plain arrays so a breakdown can be cached and
+        # rebuilt with {.new}.
+        #
+        # @return [Array<Array>]
+        attr_reader :rows
+
+        # @param rows [Array<Array>] One array per group, in {Group} member
+        #   order, as selected by {Execution::Analytics::ClassMethods#breakdown}
+        def initialize(rows)
+          @rows = rows
+          @groups = rows.map do |row|
+            Group.new(*row[0, 5], row[5].to_i, row[6].to_f, row[7].to_i, row[8].to_i,
+              row[9].to_i, row[10].to_i, row[11].to_f, parse_time(row[12]))
+          end
+        end
+
+        # A breakdown narrowed to some agents
+        #
+        # @param agent_types [Array<String>] Agent class names to keep
+        # @return [Breakdown]
+        def for_agents(agent_types)
+          names = Array(agent_types)
+          self.class.new(@rows.select { |row| names.include?(row[0]) })
+        end
+
+        # Headline figures across the whole scope
+        #
+        # @return [Hash] :total, :success, :errors, :timeouts, :cost, :tokens,
+        #   :avg_duration_ms, :success_rate, :error_rate, :last_seen
+        def totals
+          total = sum(@groups, :count)
+          success = sum(with_status("success"), :count)
+          errors = sum(with_status("error"), :count)
+          timeouts = sum(with_status("timeout"), :count)
+
+          {
+            total: total,
+            success: success,
+            errors: errors,
+            timeouts: timeouts,
+            cost: sum(@groups, :cost),
+            tokens: sum(@groups, :tokens),
+            avg_duration_ms: avg_duration(@groups),
+            success_rate: rate(success, total),
+            error_rate: rate(errors + timeouts, total),
+            last_seen: @groups.filter_map(&:last_seen).max
+          }
+        end
+
+        # Per-agent stats
+        #
+        # @return [Hash{String => Hash}] Agent type => :count, :total_cost,
+        #   :total_tokens, :avg_cost, :avg_duration_ms, :success_rate
+        def agent_stats
+          @groups.group_by(&:agent_type).transform_values do |groups|
+            count = sum(groups, :count)
+            cost = sum(groups, :cost)
+
+            {
+              count: count,
+              total_cost: cost,
+              total_tokens: sum(groups, :tokens),
+              avg_cost: (count > 0) ? (cost / count).round(6) : 0,
+              avg_duration_ms: avg_duration(groups),
+              success_rate: rate(sum(groups.select { |g| g.status == "success" }, :count), count)
+            }
+          end
+        end
+
+        # Per-model stats, attributed to the model that actually ran
+        #
+        # @return [Array<Hash>] Sorted by total cost, most expensive first
+        def model_stats
+          overall_cost = sum(@groups, :cost)
+
+          @groups.group_by(&:billed_model_id).map do |model_id, groups|
+            count = sum(groups, :count)
+            cost = sum(groups, :cost)
+            tokens = sum(groups, :tokens)
+
+            {
+              model_id: model_id,
+              executions: count,
+              total_cost: cost,
+              total_tokens: tokens,
+              avg_duration_ms: avg_duration(groups),
+              success_rate: rate(sum(groups.select { |g| g.status == "success" }, :count), count),
+              cost_per_1k_tokens: (tokens > 0) ? (cost / tokens * 1000).round(4) : 0,
+              cost_percentage: (overall_cost > 0) ? (cost / overall_cost * 100).round(1) : 0
+            }
+          end.sort_by { |m| -m[:total_cost] }
+        end
+
+        # Usage per configured model, most expensive first
+        #
+        # Unlike {#model_stats} this groups on the model the agent asked for,
+        # which is what the "move these runs to a cheaper model" comparison
+        # needs.
+        #
+        # @return [Array<Hash>] :model_id, :runs, :cost, :tokens, :cost_per_run,
+        #   :cost_per_1k_tokens
+        def configured_model_usage
+          @groups.group_by(&:model_id).map do |model_id, groups|
+            count = sum(groups, :count)
+            cost = sum(groups, :cost)
+            tokens = sum(groups, :tokens)
+
+            {
+              model_id: model_id,
+              runs: count,
+              cost: cost,
+              tokens: tokens,
+              cost_per_run: (count > 0) ? (cost / count) : 0,
+              cost_per_1k_tokens: (tokens > 0) ? (cost / tokens * 1000) : 0
+            }
+          end.sort_by { |m| -m[:cost] }
+        end
+
+        # Most frequent error classes
+        #
+        # @param limit [Integer] Max error classes to return
+        # @return [Array<Hash>] :error_class, :count, :percentage, :last_seen
+        def top_errors(limit: 5)
+          errors = with_status("error")
+          total = sum(errors, :count)
+
+          errors.group_by(&:error_class).map do |error_class, groups|
+            count = sum(groups, :count)
+
+            {
+              error_class: error_class || "Unknown Error",
+              count: count,
+              percentage: rate(count, total),
+              last_seen: groups.filter_map(&:last_seen).max
+            }
+          end.sort_by { |e| -e[:count] }.first(limit)
+        end
+
+        # Money spent on executions that ended in an error
+        #
+        # @param limit [Integer] Max (error class, agent) pairs to return
+        # @return [Hash] :total_cost, :total_count, and :breakdown — the
+        #   costliest (error class, agent) pairs
+        def error_cost(limit: 10)
+          errors = with_status("error")
+
+          pairs = errors.group_by { |g| [g.error_class, g.agent_type] }.map do |(error_class, agent_type), groups|
+            {
+              error_class: error_class || "Unknown",
+              agent_type: agent_type,
+              count: sum(groups, :count),
+              cost: sum(groups, :cost),
+              last_seen: groups.filter_map(&:last_seen).max
+            }
+          end
+
+          {
+            total_cost: sum(errors, :cost),
+            total_count: sum(errors, :count),
+            breakdown: pairs.sort_by { |e| -e[:cost] }.first(limit)
+          }
+        end
+
+        # Cache hit rate and the spend those hits avoided
+        #
+        # A cache hit makes no API call, so its own cost is always zero; the
+        # saving is estimated at the mean cost of the misses in the same scope.
+        #
+        # @return [Hash] :count, :estimated_savings, :hit_rate, :total_executions
+        def cache_savings
+          total = sum(@groups, :count)
+          return {count: 0, estimated_savings: 0, hit_rate: 0, total_executions: 0} if total.zero?
+
+          hits = sum(@groups, :cache_hits)
+          misses = total - hits
+          avg_miss_cost = misses.positive? ? (sum(@groups, :miss_cost) / misses) : 0.0
+
+          {
+            count: hits,
+            estimated_savings: (hits * avg_miss_cost).round(6),
+            hit_rate: rate(hits, total),
+            total_executions: total
+          }
+        end
+
+        private
+
+        def with_status(status)
+          @groups.select { |g| g.status == status }
+        end
+
+        def sum(groups, field)
+          groups.sum { |g| g[field] }
+        end
+
+        def rate(part, whole)
+          (whole > 0) ? (part.to_f / whole * 100).round(1) : 0.0
+        end
+
+        def avg_duration(groups)
+          samples = sum(groups, :duration_count)
+          (samples > 0) ? (sum(groups, :duration_sum) / samples) : 0
+        end
+
+        # MAX(created_at) comes back as a Time on PostgreSQL and as a UTC
+        # string on SQLite.
+        def parse_time(value)
+          value.is_a?(String) ? ActiveSupport::TimeZone["UTC"].parse(value) : value
+        end
+      end
+    end
+  end
+end