llm_cost_tracker 0.14.2 → 0.15.0

data/app/services/llm_cost_tracker/dashboard/data_quality/stats_query.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module DataQuality
+      class StatsQuery
+        MISSING_RESPONSE_ID = "provider_response_id IS NULL OR provider_response_id = ''"
+
+        def self.call(scope)
+          new(scope).call
+        end
+
+        def initialize(scope)
+          @scope = scope
+          @connection = scope.lease_connection
+        end
+
+        def call
+          scope.unscope(:order).select(selects.join(", ")).take
+        end
+
+        private
+
+        attr_reader :scope, :connection
+
+        def selects
+          [
+            "COUNT(*) AS total_calls",
+            "#{count_where(Charges::CostStatus.unknown_pricing_sql)} AS unknown_pricing_count",
+            "COUNT(*) - #{count_where(tagged_predicate)} AS untagged_calls_count",
+            "#{count_where('latency_ms IS NULL')} AS missing_latency_count",
+            "#{count_where('stream')} AS streaming_count",
+            "#{count_where(streaming_missing_usage_predicate)} AS streaming_missing_usage_count",
+            "#{count_where(MISSING_RESPONSE_ID)} AS missing_provider_response_id_count",
+            *token_sums,
+            "#{billable_tokens} AS billable_tokens",
+            "#{hidden_output_share} AS hidden_output_share"
+          ]
+        end
+
+        def token_sums
+          [*Usage::Catalog.token_priced.map(&:token_key), :hidden_output_tokens].map do |column|
+            "#{column_sum(column)} AS #{column}"
+          end
+        end
+
+        def billable_tokens
+          Usage::Catalog.token_priced.map { |component| column_sum(component.token_key) }.join(" + ")
+        end
+
+        def hidden_output_share
+          output = column_sum(:output_tokens)
+          "CASE WHEN #{output} > 0 THEN #{column_sum(:hidden_output_tokens)} * 100.0 / #{output} ELSE 0 END"
+        end
+
+        def tagged_predicate
+          tags = LlmCostTracker::CallTag.quoted_table_name
+          calls = scope.klass.quoted_table_name
+          "EXISTS (SELECT 1 FROM #{tags} WHERE #{tags}.llm_cost_tracker_call_id = #{calls}.id " \
+            "AND #{tags}.#{connection.quote_column_name('value')} != '')"
+        end
+
+        def streaming_missing_usage_predicate
+          "stream AND (#{DataQuality.unknown_usage_sql(connection)})"
+        end
+
+        def column_sum(column)
+          "COALESCE(SUM(#{connection.quote_column_name(column)}), 0)"
+        end
+
+        def count_where(predicate)
+          "COALESCE(SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END), 0)"
+        end
+      end
+    end
+  end
+end

data/app/services/llm_cost_tracker/dashboard/data_quality/summary.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module DataQuality
+      Summary = ::Data.define(
+        :total,
+        :unknown_pricing_count,
+        :untagged_calls_count,
+        :missing_latency_count,
+        :streaming_count,
+        :streaming_missing_usage,
+        :missing_provider_response_id_count
+      ) do
+        def self.from_stats(stats)
+          new(
+            total: stats.total_calls.to_i,
+            unknown_pricing_count: stats.unknown_pricing_count.to_i,
+            untagged_calls_count: stats.untagged_calls_count.to_i,
+            missing_latency_count: stats.missing_latency_count.to_i,
+            streaming_count: stats.streaming_count.to_i,
+            streaming_missing_usage: stats.streaming_missing_usage_count.to_i,
+            missing_provider_response_id_count: stats.missing_provider_response_id_count.to_i
+          )
+        end
+
+        def calls_with_pricing = total - unknown_pricing_count
+        def tagged_calls = total - untagged_calls_count
+        def calls_with_latency = total - missing_latency_count
+        def streams_with_usage = streaming_count - streaming_missing_usage
+        def calls_with_provider_response_id = total - missing_provider_response_id_count
+
+        def unknown_pricing_share = Percent.of(unknown_pricing_count, total)
+        def untagged_share = Percent.of(untagged_calls_count, total)
+        def missing_latency_share = Percent.of(missing_latency_count, total)
+        def streaming_share = Percent.of(streaming_count, total)
+        def streaming_missing_usage_share = Percent.of(streaming_missing_usage, streaming_count)
+
+        def cost_coverage = Percent.of(calls_with_pricing, total)
+        def tag_coverage = Percent.of(tagged_calls, total)
+        def latency_coverage = Percent.of(calls_with_latency, total)
+        def stream_coverage = Percent.of(streams_with_usage, streaming_count)
+        def provider_response_id_coverage = Percent.of(calls_with_provider_response_id, total)
+      end
+    end
+  end
+end

data/app/services/llm_cost_tracker/dashboard/data_quality.rb

@@ -7,36 +7,22 @@ module LlmCostTracker
       QuarantinedInbox = ::Data.define(:count, :total_cost)
       UnseenBudgetTags = ::Data.define(:keys)
       StreamingHealthRow = ::Data.define(:provider, :streams, :with_usage, :unknown, :unknown_share)
-      Summary = ::Data.define(:total,
-                              :unknown_pricing_count,
-                              :untagged_calls_count,
-                              :missing_latency_count,
-                              :streaming_count,
-                              :streaming_missing_usage,
-                              :calls_with_pricing,
-                              :tagged_calls,
-                              :calls_with_latency,
-                              :streams_with_usage,
-                              :calls_with_provider_response_id,
-                              :unknown_pricing_share,
-                              :untagged_share,
-                              :missing_latency_share,
-                              :streaming_share,
-                              :streaming_missing_usage_share,
-                              :cost_coverage,
-                              :tag_coverage,
-                              :latency_coverage,
-                              :stream_coverage,
-                              :provider_response_id_coverage)
 
       class << self
         def call(scope: LlmCostTracker::Call.all)
-          scope.unscope(:order).select(aggregate_selects(scope)).take
+          StatsQuery.call(scope)
+        end
+
+        def summary(stats)
+          Summary.from_stats(stats)
+        end
+
+        def unknown_usage_sql(connection)
+          "usage_source = #{connection.quote(LlmCostTracker::Usage::Source::UNKNOWN)} OR usage_source IS NULL"
         end
 
         def quarantined_inbox
-          return nil unless Ingestion.async?
-          return nil unless Ingestion::InboxEntry.table_exists?
+          return nil unless Ingestion.async? && Ingestion::InboxEntry.table_exists?
 
           row = Ingestion::InboxEntry
                 .quarantined
@@ -47,53 +33,10 @@ module LlmCostTracker
 
         def unseen_budget_tags
           budgeted = Budget::PerTag.configured
-          return nil if budgeted.empty?
-          return nil unless Budget::PerTag.columns?
-          return nil unless LlmCostTracker::CallTag.exists?
+          return nil if budgeted.empty? || !Budget::PerTag.columns? || !LlmCostTracker::CallTag.exists?
 
           unseen = budgeted.keys.reject { |key| LlmCostTracker::CallTag.where(key: key).where.not(value: "").exists? }
-          return nil if unseen.empty?
-
-          UnseenBudgetTags.new(keys: unseen)
-        end
-
-        def summary(stats)
-          total = stats.total_calls.to_i
-          unknown_pricing_count = stats.unknown_pricing_count.to_i
-          untagged_calls_count = stats.untagged_calls_count.to_i
-          missing_latency_count = stats.missing_latency_count.to_i
-          streaming_count = stats.streaming_count.to_i
-          streaming_missing_usage = stats.streaming_missing_usage_count.to_i
-          missing_provider_response_id_count = stats.missing_provider_response_id_count.to_i
-          calls_with_pricing = total - unknown_pricing_count
-          tagged_calls = total - untagged_calls_count
-          calls_with_latency = total - missing_latency_count
-          streams_with_usage = streaming_count - streaming_missing_usage
-          calls_with_provider_response_id = total - missing_provider_response_id_count
-
-          Summary.new(
-            total,
-            unknown_pricing_count,
-            untagged_calls_count,
-            missing_latency_count,
-            streaming_count,
-            streaming_missing_usage,
-            calls_with_pricing,
-            tagged_calls,
-            calls_with_latency,
-            streams_with_usage,
-            calls_with_provider_response_id,
-            percentage(unknown_pricing_count, total),
-            percentage(untagged_calls_count, total),
-            percentage(missing_latency_count, total),
-            percentage(streaming_count, total),
-            percentage(streaming_missing_usage, streaming_count),
-            percentage(calls_with_pricing, total),
-            percentage(tagged_calls, total),
-            percentage(calls_with_latency, total),
-            percentage(streams_with_usage, streaming_count),
-            percentage(calls_with_provider_response_id, total)
-          )
+          UnseenBudgetTags.new(keys: unseen) unless unseen.empty?
         end
 
         def unknown_pricing_by_model(scope, total_calls:)
@@ -107,101 +50,57 @@ module LlmCostTracker
                  UnknownPricingRow.new(provider: row.provider,
                                        model: row.model,
                                        calls: calls,
-                                       share_percent: percentage(calls, total_calls))
+                                       share_percent: Percent.of(calls, total_calls))
                end
         end
 
         def service_charge_rows(scope)
           call_table = LlmCostTracker::Call.quoted_table_name
-          line_item_table = LlmCostTracker::CallLineItem.quoted_table_name
-          relation = LlmCostTracker::CallLineItem
-                     .where.not(unit: "token")
-                     .joins(:call)
-                     .merge(scope.unscope(:select, :order))
-
-          relation
-            .group("#{call_table}.provider", "#{line_item_table}.kind", "#{line_item_table}.cost_status")
-            .order(Arel.sql("COALESCE(SUM(#{line_item_table}.cost), 0) DESC"), Arel.sql("COUNT(*) DESC"))
+          item_table = LlmCostTracker::CallLineItem.quoted_table_name
+
+          LlmCostTracker::CallLineItem
+            .where.not(unit: "token")
+            .joins(:call)
+            .merge(scope.unscope(:select, :order))
+            .group("#{call_table}.provider", "#{item_table}.kind", "#{item_table}.cost_status")
+            .order(Arel.sql("COALESCE(SUM(#{item_table}.cost), 0) DESC"), Arel.sql("COUNT(*) DESC"))
             .select(
               "#{call_table}.provider AS provider",
-              "#{line_item_table}.kind AS component",
-              "#{line_item_table}.cost_status AS cost_status",
+              "#{item_table}.kind AS component",
+              "#{item_table}.cost_status AS cost_status",
               "COUNT(*) AS charges_count",
-              "COALESCE(SUM(#{line_item_table}.quantity), 0) AS quantity",
-              "COALESCE(SUM(#{line_item_table}.cost), 0) AS total_cost"
+              "COALESCE(SUM(#{item_table}.quantity), 0) AS quantity",
+              "COALESCE(SUM(#{item_table}.cost), 0) AS total_cost"
             )
             .limit(10)
         end
 
+        def component_costs(scope)
+          item_table = LlmCostTracker::CallLineItem.quoted_table_name
+          dimensions = %w[kind direction cache_state].map { |column| "#{item_table}.#{column}" }
+          rows = LlmCostTracker::CallLineItem
+                 .where(unit: "token")
+                 .joins(:call)
+                 .merge(scope.unscope(:select, :order, :group))
+                 .group(*dimensions)
+                 .pluck(*dimensions.map { |column| Arel.sql(column) }, Arel.sql("COALESCE(SUM(#{item_table}.cost), 0)"))
+          Usage::Catalog.costs_by_component(rows)
+        end
+
         def usage_rows(stats, component_costs: {})
           billable_tokens = stats.billable_tokens.to_f
-
           rows = Usage::Catalog.token_priced.map do |component|
             token_value = stats[component.token_key].to_i
-
             {
               token_key: component.token_key,
               cost_key: component.cost_key,
               token_value: token_value,
               cost_value: component_costs[component.key],
-              share_percent: percentage(token_value, billable_tokens),
+              share_percent: Percent.of(token_value, billable_tokens),
               share_basis: nil
             }
           end
-
-          rows + [
-            {
-              token_key: :hidden_output_tokens,
-              cost_key: nil,
-              token_value: stats.hidden_output_tokens.to_i,
-              cost_value: nil,
-              share_percent: stats.hidden_output_share.to_f,
-              share_basis: :output
-            }
-          ]
-        end
-
-        def component_costs(scope)
-          line_item_table = LlmCostTracker::CallLineItem.quoted_table_name
-          rows = LlmCostTracker::CallLineItem
-                 .where(unit: "token")
-                 .joins(:call)
-                 .merge(scope.unscope(:select, :order, :group))
-                 .group("#{line_item_table}.kind",
-                        "#{line_item_table}.direction",
-                        "#{line_item_table}.cache_state")
-                 .pluck(Arel.sql("#{line_item_table}.kind"),
-                        Arel.sql("#{line_item_table}.direction"),
-                        Arel.sql("#{line_item_table}.cache_state"),
-                        Arel.sql("COALESCE(SUM(#{line_item_table}.cost), 0)"))
-          Usage::Catalog.costs_by_component(rows)
-        end
-
-        def streaming_health_rows(scope, total_streaming:)
-          return [] unless total_streaming.positive?
-
-          unknown_predicate = unknown_usage_source_predicate(scope)
-          rows = scope.unscope(:select, :order, :group)
-                      .where(stream: true)
-                      .group(:provider)
-                      .order(Arel.sql("COUNT(*) DESC"), :provider)
-                      .pluck(
-                        :provider,
-                        Arel.sql("COUNT(*)"),
-                        Arel.sql("SUM(CASE WHEN #{unknown_predicate} THEN 1 ELSE 0 END)")
-                      )
-
-          rows.map do |provider, streams, unknown|
-            streams_count = streams.to_i
-            unknown_count = unknown.to_i
-            StreamingHealthRow.new(
-              provider: provider,
-              streams: streams_count,
-              with_usage: streams_count - unknown_count,
-              unknown: unknown_count,
-              unknown_share: percentage(unknown_count, streams_count)
-            )
-          end
+          rows << hidden_output_usage_row(stats)
         end
 
         def hidden_output_summary(stats)
@@ -215,82 +114,39 @@ module LlmCostTracker
           }
         end
 
-        private
-
-        def percentage(numerator, denominator)
-          return 0.0 unless denominator.positive?
-
-          (numerator.to_f / denominator) * 100.0
-        end
-
-        def aggregate_selects(scope)
-          unknown_pricing = Charges::CostStatus.unknown_pricing_sql
-          selects = [
-            "COUNT(*) AS total_calls",
-            "#{conditional_count_sql(unknown_pricing)} AS unknown_pricing_count",
-            "COUNT(*) - #{tagged_calls_sql(scope)} AS untagged_calls_count",
-            "#{conditional_count_sql('latency_ms IS NULL')} AS missing_latency_count",
-            "#{conditional_count_sql('stream')} AS streaming_count",
-            "#{streaming_missing_usage_select(scope)} AS streaming_missing_usage_count",
-            "#{provider_response_id_select} AS missing_provider_response_id_count"
-          ]
-
-          usage_sum_columns.each do |column|
-            selects << "#{column_sum(scope, column)} AS #{column}"
-          end
-
-          selects << "#{billable_tokens_select(scope)} AS billable_tokens"
-          selects << "#{hidden_output_share_select(scope)} AS hidden_output_share"
-
-          selects.join(", ")
-        end
-
-        def usage_sum_columns
-          Usage::Catalog.token_priced.map(&:token_key) + [:hidden_output_tokens]
-        end
-
-        def billable_tokens_select(scope)
-          Usage::Catalog.token_priced
-                        .map { |component| column_sum(scope, component.token_key) }
-                        .join(" + ")
-        end
-
-        def hidden_output_share_select(scope)
-          hidden_output = column_sum(scope, :hidden_output_tokens)
-          output = column_sum(scope, :output_tokens)
-
-          "CASE WHEN #{output} > 0 THEN #{hidden_output} * 100.0 / #{output} ELSE 0 END"
-        end
-
-        def unknown_usage_source_predicate(scope)
-          quoted = scope.connection.quote(LlmCostTracker::Usage::Source::UNKNOWN)
-          "usage_source = #{quoted} OR usage_source IS NULL"
-        end
-
-        def column_sum(scope, column)
-          "COALESCE(SUM(#{scope.connection.quote_column_name(column)}), 0)"
-        end
+        def streaming_health_rows(scope, total_streaming:)
+          return [] unless total_streaming.positive?
 
-        def conditional_count_sql(predicate)
-          "COALESCE(SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END), 0)"
+          unknown_count = Arel.sql("SUM(CASE WHEN #{unknown_usage_sql(scope.lease_connection)} THEN 1 ELSE 0 END)")
+          scope.unscope(:select, :order, :group)
+               .where(stream: true)
+               .group(:provider)
+               .order(Arel.sql("COUNT(*) DESC"), :provider)
+               .pluck(:provider, Arel.sql("COUNT(*)"), unknown_count)
+               .map { |provider, streams, unknown| streaming_health_row(provider, streams.to_i, unknown.to_i) }
         end
 
-        def streaming_missing_usage_select(scope)
-          conditional_count_sql("stream AND (#{unknown_usage_source_predicate(scope)})")
-        end
+        private
 
-        def provider_response_id_select
-          predicate = "provider_response_id IS NULL OR provider_response_id = ''"
-          conditional_count_sql(predicate)
+        def hidden_output_usage_row(stats)
+          {
+            token_key: :hidden_output_tokens,
+            cost_key: nil,
+            token_value: stats.hidden_output_tokens.to_i,
+            cost_value: nil,
+            share_percent: stats.hidden_output_share.to_f,
+            share_basis: :output
+          }
         end
 
-        def tagged_calls_sql(scope)
-          calls_table = scope.klass.quoted_table_name
-          tags_table = LlmCostTracker::CallTag.quoted_table_name
-
-          "COALESCE(SUM(CASE WHEN EXISTS (SELECT 1 FROM #{tags_table} " \
-            "WHERE #{tags_table}.llm_cost_tracker_call_id = #{calls_table}.id " \
-            "AND #{tags_table}.#{scope.connection.quote_column_name('value')} != '') THEN 1 ELSE 0 END), 0)"
+        def streaming_health_row(provider, streams, unknown)
+          StreamingHealthRow.new(
+            provider: provider,
+            streams: streams,
+            with_usage: streams - unknown,
+            unknown: unknown,
+            unknown_share: Percent.of(unknown, streams)
+          )
         end
       end
     end

data/app/services/llm_cost_tracker/dashboard/filter.rb

@@ -11,6 +11,7 @@ module LlmCostTracker
         ["Streaming only", "yes"],
         ["Non-streaming only", "no"]
       ].freeze
+      STREAM_FILTER_LABELS = { "yes" => "Streaming", "no" => "Non-streaming" }.freeze
 
       class << self
         def call(scope: LlmCostTracker::Call.all, params: {}, tags: {})
@@ -90,7 +91,7 @@ module LlmCostTracker
 
       def matchable?(values)
         values.none? { |value| value.include?("\0") } ||
-          !LlmCostTracker::Ledger::Schema::Adapter.postgresql?(scope.connection)
+          !LlmCostTracker::Ledger::Schema::Adapter.postgresql?(scope.lease_connection)
       end
 
       def normalized_string(value, name)

data/app/services/llm_cost_tracker/dashboard/monthly_budget.rb

@@ -2,29 +2,22 @@
 
 module LlmCostTracker
   module Dashboard
-    module MonthlyBudget
-      module_function
-
-      def status
+    class MonthlyBudget
+      def self.status
         budget = LlmCostTracker.configuration.budgets.monthly
         return nil unless budget
 
-        budget = budget.to_f
-        now = Time.now.utc
-        month_start = now.beginning_of_month
-        month_end = now.end_of_month
-        spent = LlmCostTracker::Ledger::Period::Totals.call(%i[month], time: now).fetch(:month)
-        elapsed_seconds = now - month_start
-        total_seconds = month_end - month_start
-        projected_spent = if spent.zero? || !elapsed_seconds.positive?
-                            spent
-                          else
-                            spent * (total_seconds / elapsed_seconds)
-                          end
-        percent_used = budget.positive? ? (spent / budget) * 100.0 : 0.0
-        projected_percent_used = budget.positive? ? (projected_spent / budget) * 100.0 : 0.0
-        projected_delta = projected_spent - budget
+        new(budget.to_f, Time.now.utc).status
+      end
 
+      def initialize(budget, now)
+        @budget = budget
+        @now = now
+        @spent = LlmCostTracker::Ledger::Period::Totals.call(%i[month], time: now).fetch(:month)
+        @projected_spent = project(@spent)
+      end
+
+      def status
         {
           budget: budget,
           spent: spent,
@@ -32,31 +25,45 @@ module LlmCostTracker
           projected_spent: projected_spent,
           projected_percent_used: projected_percent_used,
           projected_delta: projected_delta,
-          projection_end_label: month_end.strftime("%b %-d"),
-          fill_modifier: fill_modifier(percent_used),
-          progress_percent: clamped_percent(percent_used),
-          projected_marker_percent: clamped_percent(projected_percent_used),
-          projected_delta_amount: projected_delta.abs,
-          projected_delta_direction: projected_delta.positive? ? "over" : "under",
-          projected_delta_status_class: projected_delta_status_class(projected_delta)
+          projection_end_label: now.end_of_month.strftime("%b %-d"),
+          fill_modifier: fill_modifier,
+          progress_percent: percent_used.clamp(0.0, 100.0),
+          projected_marker_percent: projected_percent_used.clamp(0.0, 100.0),
+          **projected_delta_labels
         }
       end
 
-      def clamped_percent(value)
-        value.clamp(0.0, 100.0)
+      private
+
+      attr_reader :budget, :now, :spent, :projected_spent
+
+      def project(amount)
+        month_start = now.beginning_of_month
+        elapsed_seconds = now - month_start
+        return amount if amount.zero? || !elapsed_seconds.positive?
+
+        amount * ((now.end_of_month - month_start) / elapsed_seconds)
       end
 
-      def fill_modifier(percent)
-        return "lct-budget-fill--over" if percent >= 100.0
-        return "lct-budget-fill--warn" if percent >= 80.0
+      def percent_used = share_of_budget(spent)
+      def projected_percent_used = share_of_budget(projected_spent)
+      def share_of_budget(amount) = budget.positive? ? (amount / budget) * 100.0 : 0.0
+      def projected_delta = projected_spent - budget
+
+      def fill_modifier
+        return "lct-budget-fill--over" if percent_used >= 100.0
+        return "lct-budget-fill--warn" if percent_used >= 80.0
 
         ""
       end
 
-      def projected_delta_status_class(delta)
-        return "lct-budget-projection-status--over" if delta.positive?
-
-        "lct-budget-projection-status--under"
+      def projected_delta_labels
+        direction = projected_delta.positive? ? "over" : "under"
+        {
+          projected_delta_amount: projected_delta.abs,
+          projected_delta_direction: direction,
+          projected_delta_status_class: "lct-budget-projection-status--#{direction}"
+        }
       end
     end
   end

data/app/services/llm_cost_tracker/dashboard/percent.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module Percent
+      def self.of(part, whole)
+        whole = whole.to_f
+        whole.positive? ? (part.to_f / whole) * 100.0 : 0.0
+      end
+    end
+  end
+end

data/app/services/llm_cost_tracker/dashboard/sort.rb

@@ -4,6 +4,15 @@ module LlmCostTracker
   module Dashboard
     module Sort
       DIRECTIONS = %w[asc desc].freeze
+
+      Choice = Data.define(:column, :direction)
+
+      def self.resolve(column, direction, natural_directions:, fallback:)
+        column = natural_directions.key?(column.to_s) ? column.to_s : fallback
+        direction = direction.to_s
+        direction = natural_directions.fetch(column) unless DIRECTIONS.include?(direction)
+        Choice.new(column: column, direction: direction)
+      end
     end
   end
 end

data/app/services/llm_cost_tracker/dashboard/spend_anomaly.rb

@@ -28,18 +28,14 @@ module LlmCostTracker
       attr_reader :scope, :from, :to
 
       def alerts
-        window_days = WINDOW_DAYS.to_f
-        daily_spend_by_model.each_with_object([]) do |((provider, model), daily_costs), rows|
+        daily_spend_by_model.filter_map do |(provider, model), daily_costs|
           latest_spend = daily_costs.fetch(to, 0.0)
           next unless latest_spend.positive?
 
-          baseline_days = ((to - WINDOW_DAYS)...to).map { |day| daily_costs.fetch(day, 0.0) }
-          mean = baseline_days.sum / window_days
-          variance = baseline_days.sum { |value| (value - mean)**2 } / window_days
-          threshold = mean + (2 * Math.sqrt(variance))
-          next unless latest_spend > threshold
+          mean, deviation = baseline(daily_costs)
+          next unless latest_spend > mean + (2 * deviation)
 
-          rows << {
+          {
             provider: provider,
             model: model,
             day: to,
@@ -50,22 +46,28 @@ module LlmCostTracker
         end
       end
 
-      def daily_spend_by_model
-        window = (to - WINDOW_DAYS).beginning_of_day..to.end_of_day
+      def baseline(daily_costs)
+        days = ((to - WINDOW_DAYS)...to).map { |day| daily_costs.fetch(day, 0.0) }
+        mean = days.sum / WINDOW_DAYS.to_f
+        variance = days.sum { |value| (value - mean)**2 } / WINDOW_DAYS.to_f
+        [mean, Math.sqrt(variance)]
+      end
 
-        grouped = Hash.new { |hash, key| hash[key] = Hash.new(0.0) }
+      def daily_spend_by_model
+        daily_costs = Hash.new { |hash, key| hash[key] = Hash.new(0.0) }
+        daily_totals.each do |(provider, model, day), total_cost|
+          daily_costs[[provider, model]][Date.iso8601(day.to_s)] += total_cost.to_f
+        end
+        daily_costs
+      end
 
+      def daily_totals
         scope
-          .where(tracked_at: window)
+          .where(tracked_at: (to - WINDOW_DAYS).beginning_of_day..to.end_of_day)
           .where.not(total_cost: nil)
           .group(:provider, :model)
           .group_by_period(:day, time_zone: Time.zone)
           .sum(:total_cost)
-          .each do |(provider, model, day), total_cost|
-            grouped[[provider, model]][Date.iso8601(day.to_s)] += total_cost.to_f
-          end
-
-        grouped
       end
     end
   end