llm_cost_tracker 0.7.3 → 0.9.0

data/app/models/llm_cost_tracker/call_line_item.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class CallLineItem < ActiveRecord::Base
+    belongs_to :call,
+               class_name: "LlmCostTracker::Call",
+               foreign_key: :llm_cost_tracker_call_id,
+               inverse_of: :line_items
+
+    scope :tokens, -> { where(unit: "token") }
+    scope :by_kind, ->(kind) { where(kind: kind.to_s) }
+    scope :by_direction, ->(direction) { where(direction: direction.to_s) }
+    scope :by_modality, ->(modality) { where(modality: modality.to_s) }
+    scope :cached, -> { where.not(cache_state: ["none", nil]) }
+    scope :priced, -> { where(cost_status: %w[complete free]) }
+    scope :unpriced, -> { where(cost_status: "unknown") }
+  end
+end

data/app/models/llm_cost_tracker/call_rollup.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class CallRollup < ActiveRecord::Base
+  end
+end

data/app/models/llm_cost_tracker/call_tag.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class CallTag < ActiveRecord::Base
+    belongs_to :call,
+               class_name: "LlmCostTracker::Call",
+               foreign_key: :llm_cost_tracker_call_id,
+               inverse_of: :tag_records
+
+    scope :with_key, ->(key) { where(key: key.to_s) }
+  end
+end

data/app/models/llm_cost_tracker/ingestion/inbox_entry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Ingestion
+    class InboxEntry < ActiveRecord::Base
+      MAX_ATTEMPTS_BEFORE_QUARANTINE = 5
+    end
+  end
+end

data/app/models/llm_cost_tracker/ingestion/lease.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require "active_record"
-
 module LlmCostTracker
   module Ingestion
     class Lease < ActiveRecord::Base
-      self.table_name = "llm_cost_tracker_ingestor_leases"
     end
   end
 end

data/app/models/llm_cost_tracker/provider_invoice.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class ProviderInvoice < ActiveRecord::Base
+    before_validation :normalize_currency
+
+    private
+
+    def normalize_currency
+      self.currency = currency.to_s.upcase if currency.present?
+    end
+  end
+end

data/app/models/llm_cost_tracker/provider_invoice_import.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class ProviderInvoiceImport < ActiveRecord::Base
+    STATE_RUNNING = "running"
+    STATE_COMPLETED = "completed"
+    STATE_FAILED = "failed"
+    STATES = [STATE_RUNNING, STATE_COMPLETED, STATE_FAILED].freeze
+
+    scope :for_source, ->(source) { where(source: source.to_s) }
+    scope :running, -> { where(state: STATE_RUNNING) }
+    scope :completed, -> { where(state: STATE_COMPLETED) }
+    scope :failed, -> { where(state: STATE_FAILED) }
+    scope :latest, -> { order(started_at: :desc, id: :desc) }
+
+    def self.resume_cursor_for(source)
+      for_source(source).latest.limit(1).pick(:cursor)
+    end
+
+    def self.last_completed_window_for(source)
+      for_source(source).completed.latest.limit(1).pick(:window_start, :window_end)
+    end
+  end
+end

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

@@ -1,44 +1,100 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/pricing"
+require "llm_cost_tracker/billing/components"
 require "llm_cost_tracker/ledger/schema/adapter"
 
 module LlmCostTracker
   module Dashboard
     class DataQuality
+      UnknownPricingRow = ::Data.define(:provider, :model, :calls, :share_percent)
+      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, :missing_provider_response_id_count,
+                              :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::Ledger::Call.all)
+        def call(scope: LlmCostTracker::Call.all)
           scope.unscope(:order).select(aggregate_selects(scope)).take
         end
 
-        def unknown_pricing_by_model(scope)
+        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, missing_provider_response_id_count, 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)
+          )
+        end
+
+        def unknown_pricing_by_model(scope, total_calls:)
           scope.unknown_pricing
-               .group(:model)
+               .group(:provider, :model)
                .order(Arel.sql("COUNT(*) DESC"))
-               .select("model, COUNT(*) AS calls")
+               .select("provider, model, COUNT(*) AS calls")
                .limit(10)
+               .map do |row|
+                 calls = row.calls.to_i
+                 UnknownPricingRow.new(provider: row.provider, model: row.model, calls: calls,
+                                       share_percent: percentage(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"))
+            .select(
+              "#{call_table}.provider AS provider",
+              "#{line_item_table}.kind AS component",
+              "#{line_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"
+            )
+            .limit(10)
         end
 
-        def usage_rows(stats)
+        def usage_rows(stats, component_costs: {})
           billable_tokens = stats.billable_tokens.to_f
 
-          rows = Pricing::COMPONENTS.map do |component|
-            token_key = component.token_key
-            cost_key = component.cost_key
-            token_value = stats[token_key].to_i
-            share_percent = if billable_tokens.positive?
-                              (token_value.to_f / billable_tokens) * 100.0
-                            else
-                              0.0
-                            end
+          rows = Billing::Components::TOKEN_PRICED.map do |component|
+            token_value = stats[component.token_key].to_i
 
             {
-              price_key: component.price_key,
-              token_key: token_key,
-              cost_key: cost_key,
+              price_key: component.key,
+              token_key: component.token_key,
+              cost_key: component.cost_key,
               token_value: token_value,
-              cost_value: stats[cost_key],
-              share_percent: share_percent,
+              cost_value: component_costs[component.key],
+              share_percent: percentage(token_value, billable_tokens),
               share_basis: nil
             }
           end
@@ -56,6 +112,48 @@ module LlmCostTracker
           ]
         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)"))
+          index_costs_by_component(rows)
+        end
+
+        def streaming_health_rows(scope, total_streaming:)
+          return [] unless total_streaming.positive?
+
+          unknown_predicate = "usage_source = 'unknown' OR usage_source IS NULL"
+          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
+        end
+
         def hidden_output_summary(stats)
           output_tokens = stats.output_tokens.to_i
           return unless output_tokens.positive?
@@ -69,10 +167,27 @@ module LlmCostTracker
 
         private
 
+        def index_costs_by_component(rows)
+          rows.each_with_object({}) do |(kind, direction, cache_state, cost), accumulator|
+            component = Billing::Components::TOKEN_PRICED.find do |item|
+              item.kind.to_s == kind.to_s &&
+                item.direction.to_s == direction.to_s &&
+                item.cache_state.to_s == cache_state.to_s
+            end
+            accumulator[component.key] = cost if component
+          end
+        end
+
+        def percentage(numerator, denominator)
+          return 0.0 unless denominator.positive?
+
+          (numerator.to_f / denominator) * 100.0
+        end
+
         def aggregate_selects(scope)
           selects = [
             "COUNT(*) AS total_calls",
-            "#{conditional_count_sql('total_cost IS NULL')} AS unknown_pricing_count",
+            "#{conditional_count_sql(unknown_pricing_predicate(scope))} AS unknown_pricing_count",
             "#{tagged_calls_sql(scope)} AS tagged_calls_count",
             "COUNT(*) - #{tagged_calls_sql(scope)} AS untagged_calls_count",
             "#{conditional_count_sql('latency_ms IS NULL')} AS missing_latency_count",
@@ -92,11 +207,11 @@ module LlmCostTracker
         end
 
         def usage_sum_columns
-          Pricing::COMPONENTS.map(&:token_key) + [:hidden_output_tokens] + Pricing::COMPONENTS.map(&:cost_key)
+          Billing::Components::TOKEN_PRICED.map(&:token_key) + [:hidden_output_tokens]
         end
 
         def billable_tokens_select(scope)
-          Pricing::COMPONENTS
+          Billing::Components::TOKEN_PRICED
             .map { |component| column_sum(scope, component.token_key) }
             .join(" + ")
         end
@@ -108,6 +223,15 @@ module LlmCostTracker
           "CASE WHEN #{output} > 0 THEN #{hidden_output} * 100.0 / #{output} ELSE 0 END"
         end
 
+        def unknown_pricing_predicate(scope)
+          values = [
+            LlmCostTracker::Billing::CostStatus::UNKNOWN,
+            LlmCostTracker::Billing::CostStatus::PARTIAL
+          ].map { |value| scope.connection.quote(value) }
+
+          "total_cost IS NULL OR cost_status IN (#{values.join(', ')})"
+        end
+
         def column_sum(scope, column)
           "COALESCE(SUM(#{scope.connection.quote_column_name(column)}), 0)"
         end
@@ -127,15 +251,11 @@ module LlmCostTracker
         end
 
         def tagged_calls_sql(scope)
-          table = scope.klass.quoted_table_name
-          connection = scope.connection
-          column = "#{table}.#{connection.quote_column_name('tags')}"
-
-          if Ledger::Schema::Adapter.postgresql?(connection)
-            "COALESCE(SUM(CASE WHEN #{column} <> '{}'::jsonb THEN 1 ELSE 0 END), 0)"
-          else
-            "COALESCE(SUM(CASE WHEN JSON_LENGTH(#{column}) > 0 THEN 1 ELSE 0 END), 0)"
-          end
+          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) THEN 1 ELSE 0 END), 0)"
         end
       end
     end

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

@@ -13,7 +13,7 @@ module LlmCostTracker
       end
 
       def self.parse(params, key)
-        value = LlmCostTracker::Dashboard::Params.with_indifferent_access(params)[key].to_s.strip.presence
+        value = LlmCostTracker::Dashboard::Params.to_hash(params).symbolize_keys[key].to_s.strip.presence
         return nil unless value
 
         Date.iso8601(value)

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

@@ -6,14 +6,14 @@ module LlmCostTracker
   module Dashboard
     class Filter
       class << self
-        def call(scope: LlmCostTracker::Ledger::Call.all, params: {})
+        def call(scope: LlmCostTracker::Call.all, params: {})
           new(scope: scope, params: params).relation
         end
       end
 
       def initialize(scope:, params:)
         @scope = scope
-        @params = LlmCostTracker::Dashboard::Params.with_indifferent_access(params)
+        @params = LlmCostTracker::Dashboard::Params.to_hash(params).symbolize_keys
       end
 
       def relation
@@ -35,11 +35,13 @@ module LlmCostTracker
         to_date = Dashboard::DateRange.parse(params, :to)
         Dashboard::DateRange.validate!(from: from_date, to: to_date)
 
-        from = from_date&.beginning_of_day
-        to = to_date&.end_of_day
-        relation = relation.where(tracked_at: from..) if from
-        relation = relation.where(tracked_at: ..to) if to
+        default_range = Dashboard::DateRange.call(params: params)
+        from_date ||= default_range.from
+        to_date ||= default_range.to
+
         relation
+          .where(tracked_at: from_date.beginning_of_day..)
+          .where(tracked_at: ..to_date.end_of_day)
       end
 
       def apply_exact_filter(relation, key)

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

@@ -6,18 +6,25 @@ module LlmCostTracker
   module Dashboard
     class OverviewStats
       class << self
-        def call(scope: LlmCostTracker::Ledger::Call.all, previous_scope: nil)
-          scope.select(aggregate_selects(previous_scope: previous_scope)).take
+        def call(scope: LlmCostTracker::Call.all, previous_scope: nil)
+          return scope.select(aggregate_selects).take unless previous_scope
+
+          scope.klass
+               .from("(#{scope.unscope(:select, :order).to_sql}) AS current_calls")
+               .joins("CROSS JOIN (#{previous_aggregate_sql(previous_scope)}) AS previous_stats")
+               .select(aggregate_selects(table_name: "current_calls", previous: true))
+               .take
         end
 
         def monthly_budget_status
           budget = LlmCostTracker.configuration.monthly_budget
           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[monthly], time: now).fetch(:monthly)
+          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?
@@ -25,39 +32,65 @@ module LlmCostTracker
                             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
 
           {
-            budget: budget.to_f,
+            budget: budget,
             spent: spent,
-            percent_used: budget.to_f.positive? ? (spent / budget.to_f) * 100.0 : 0.0,
+            percent_used: percent_used,
             projected_spent: projected_spent,
-            projected_percent_used: budget.to_f.positive? ? (projected_spent / budget.to_f) * 100.0 : 0.0,
-            projected_delta: projected_spent - budget.to_f,
-            projection_end_label: month_end.strftime("%b %-d")
+            projected_percent_used: projected_percent_used,
+            projected_delta: projected_delta,
+            projection_end_label: month_end.strftime("%b %-d"),
+            fill_modifier: budget_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)
           }
         end
 
+        UNKNOWN_PRICING_COST_STATUSES = [
+          LlmCostTracker::Billing::CostStatus::UNKNOWN,
+          LlmCostTracker::Billing::CostStatus::PARTIAL
+        ].freeze
+
         private
 
-        def aggregate_selects(previous_scope:)
+        def aggregate_selects(table_name: nil, previous: false)
+          total_cost = table_name ? "#{table_name}.total_cost" : "total_cost"
+          latency_ms = table_name ? "#{table_name}.latency_ms" : "latency_ms"
+          cost_status = table_name ? "#{table_name}.cost_status" : "cost_status"
           average_cost_sql = <<~SQL.squish
             CASE WHEN COUNT(*) > 0
-            THEN COALESCE(SUM(total_cost), 0) * 1.0 / COUNT(*)
+            THEN COALESCE(SUM(#{total_cost}), 0) * 1.0 / COUNT(*)
             ELSE 0 END
           SQL
+          unknown_pricing_sql = <<~SQL.squish
+            SUM(CASE WHEN #{total_cost} IS NULL OR
+                          #{cost_status} IN (#{UNKNOWN_PRICING_COST_STATUSES.map { |s| connection.quote(s) }.join(', ')})
+                THEN 1 ELSE 0 END)
+          SQL
           selects = [
             "COUNT(*) AS total_calls",
-            "COALESCE(SUM(total_cost), 0) AS total_cost",
+            "COALESCE(SUM(#{total_cost}), 0) AS total_cost",
             "#{average_cost_sql} AS average_cost_per_call",
-            "SUM(CASE WHEN total_cost IS NULL THEN 1 ELSE 0 END) AS unknown_pricing_count",
-            "AVG(latency_ms) AS average_latency_ms"
+            "#{unknown_pricing_sql} AS unknown_pricing_count",
+            "AVG(#{latency_ms}) AS average_latency_ms"
           ]
-          selects.concat(previous_selects(previous_scope))
+          selects.concat(previous_selects(previous))
           selects.join(", ")
         end
 
-        def previous_selects(previous_scope)
-          unless previous_scope
+        def connection
+          LlmCostTracker::Call.connection
+        end
+
+        def previous_selects(previous)
+          unless previous
             return [
               "NULL AS previous_total_cost",
               "NULL AS previous_total_calls",
@@ -66,11 +99,11 @@ module LlmCostTracker
             ]
           end
 
-          previous_cost_sql = aggregate_subquery(previous_scope, "COALESCE(SUM(total_cost), 0)")
-          previous_calls_sql = aggregate_subquery(previous_scope, "COUNT(*)")
+          previous_cost_sql = "MAX(previous_stats.total_cost)"
+          previous_calls_sql = "MAX(previous_stats.total_calls)"
           cost_delta_sql = <<~SQL.squish
             CASE WHEN (#{previous_cost_sql}) = 0 THEN NULL
-            ELSE ((COALESCE(SUM(total_cost), 0) - (#{previous_cost_sql})) * 100.0 / (#{previous_cost_sql}))
+            ELSE ((COALESCE(SUM(current_calls.total_cost), 0) - (#{previous_cost_sql})) * 100.0 / (#{previous_cost_sql}))
             END
           SQL
           calls_delta_sql = <<~SQL.squish
@@ -86,8 +119,28 @@ module LlmCostTracker
           ]
         end
 
-        def aggregate_subquery(scope, expression)
-          scope.unscope(:select, :order).select(expression).to_sql
+        def previous_aggregate_sql(scope)
+          scope
+            .unscope(:select, :order)
+            .select("COALESCE(SUM(total_cost), 0) AS total_cost", "COUNT(*) AS total_calls")
+            .to_sql
+        end
+
+        def clamped_percent(value)
+          value.clamp(0.0, 100.0)
+        end
+
+        def budget_fill_modifier(percent)
+          return "lct-budget-fill--over" if percent >= 100.0
+          return "lct-budget-fill--warn" if percent >= 80.0
+
+          ""
+        end
+
+        def projected_delta_status_class(delta)
+          return "lct-budget-projection-status--over" if delta.positive?
+
+          "lct-budget-projection-status--under"
         end
       end
     end

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

@@ -10,7 +10,7 @@ module LlmCostTracker
       attr_reader :page, :per
 
       def self.call(params)
-        params = Params.with_indifferent_access(params)
+        params = Params.to_hash(params).symbolize_keys
         new(
           page: integer_param(params, :page, default: MIN_PAGE, min: MIN_PAGE),
           per: integer_param(params, :per, default: DEFAULT_PER, min: 1, max: MAX_PER)
@@ -46,13 +46,15 @@ module LlmCostTracker
       end
 
       def next_page?(total_count)
-        offset + per < total_count.to_i
+        total_count = total_count.to_i
+        offset + per < total_count
       end
 
       def total_pages(total_count)
-        return MIN_PAGE if total_count.to_i <= 0
+        total_count = total_count.to_i
+        return MIN_PAGE unless total_count.positive?
 
-        [(total_count.to_f / per).ceil, MIN_PAGE].max
+        ((total_count + per - 1) / per)
       end
     end
   end

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

@@ -17,8 +17,14 @@ module LlmCostTracker
           {}
         end
 
-        def with_indifferent_access(value)
-          to_hash(value).with_indifferent_access
+        def tag_query(value)
+          to_hash(value).each_with_object({}) do |(key, tag_value), tags|
+            key = key.to_s
+            tag_value = tag_value.to_s
+            next if key.blank? || tag_value.blank?
+
+            tags[key] = tag_value
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module LlmCostTracker
   module Dashboard
     class ProviderBreakdown
-      def self.call(scope: LlmCostTracker::Ledger::Call.all)
+      def self.call(scope: LlmCostTracker::Call.all)
         new(scope: scope).rows
       end
 

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

@@ -6,7 +6,7 @@ module LlmCostTracker
       WINDOW_DAYS = 7
 
       class << self
-        def call(from:, to:, scope: LlmCostTracker::Ledger::Call.all)
+        def call(from:, to:, scope: LlmCostTracker::Call.all)
           new(scope: scope, from: from, to: to).alert
         end
       end
@@ -28,13 +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|
           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.to_f
-          variance = baseline_days.sum { |value| (value - mean)**2 } / WINDOW_DAYS.to_f
+          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