llm_cost_tracker 0.7.0 → 0.7.2

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

@@ -2,10 +2,8 @@
 
 module LlmCostTracker
   module Dashboard
-    ProviderRow = Data.define(:provider, :calls, :total_cost, :share_percent)
-
     class ProviderBreakdown
-      def self.call(scope: LlmCostTracker::LlmApiCall.all)
+      def self.call(scope: LlmCostTracker::Ledger::Call.all)
         new(scope: scope).rows
       end
 
@@ -14,28 +12,28 @@ module LlmCostTracker
       end
 
       def rows
-        grouped = scope
-                  .group(:provider)
-                  .select("provider, COUNT(*) AS calls_count, COALESCE(SUM(total_cost), 0) AS total_cost_sum")
-                  .order(Arel.sql("total_cost_sum DESC, calls_count DESC"))
-                  .to_a
-
-        total_cost = grouped.sum { |row| row.total_cost_sum.to_f }
-
-        grouped.map do |row|
-          cost = row.total_cost_sum.to_f
-          ProviderRow.new(
-            provider: row.provider,
-            calls: row.calls_count.to_i,
-            total_cost: cost,
-            share_percent: total_cost.positive? ? (cost / total_cost) * 100.0 : 0.0
-          )
-        end
+        scope
+          .group(:provider)
+          .select(selects)
+          .order(Arel.sql("total_cost DESC, calls DESC"))
       end
 
       private
 
       attr_reader :scope
+
+      def selects
+        <<~SQL.squish
+          provider,
+          COUNT(*) AS calls,
+          COALESCE(SUM(total_cost), 0) AS total_cost,
+          CASE
+            WHEN SUM(COALESCE(SUM(total_cost), 0)) OVER () > 0
+              THEN COALESCE(SUM(total_cost), 0) / SUM(COALESCE(SUM(total_cost), 0)) OVER () * 100.0
+            ELSE 0
+          END AS share_percent
+        SQL
+      end
     end
   end
 end

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

@@ -2,20 +2,11 @@
 
 module LlmCostTracker
   module Dashboard
-    SpendAnomalyData = Data.define(
-      :provider,
-      :model,
-      :day,
-      :latest_spend,
-      :baseline_mean,
-      :ratio
-    )
-
     class SpendAnomaly
       WINDOW_DAYS = 7
 
       class << self
-        def call(from:, to:, scope: LlmCostTracker::LlmApiCall.all)
+        def call(from:, to:, scope: LlmCostTracker::Ledger::Call.all)
           new(scope: scope, from: from, to: to).alert
         end
       end
@@ -29,7 +20,7 @@ module LlmCostTracker
       def alert
         return nil if from > (to - WINDOW_DAYS)
 
-        alerts.max_by { |item| [item.ratio || 0.0, item.latest_spend] }
+        alerts.max_by { |item| [item.fetch(:ratio) || 0.0, item.fetch(:latest_spend)] }
       end
 
       private
@@ -47,14 +38,14 @@ module LlmCostTracker
           threshold = mean + (2 * Math.sqrt(variance))
           next unless latest_spend > threshold
 
-          rows << SpendAnomalyData.new(
+          rows << {
             provider: provider,
             model: model,
             day: to,
             latest_spend: latest_spend,
             baseline_mean: mean,
             ratio: mean.positive? ? (latest_spend / mean) : nil
-          )
+          }
         end
       end
 

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

@@ -2,86 +2,58 @@
 
 module LlmCostTracker
   module Dashboard
-    TagBreakdownRow = Data.define(
-      :value,
-      :calls,
-      :total_cost,
-      :average_cost_per_call
-    )
-
-    TagBreakdownResult = Data.define(
-      :rows,
-      :total_calls,
-      :tagged_calls,
-      :distinct_values,
-      :limit
-    ) do
-      def limited? = distinct_values > rows.size
-    end
-
     class TagBreakdown
       DEFAULT_LIMIT = 100
 
       class << self
-        def call(key:, scope: LlmCostTracker::LlmApiCall.all, limit: DEFAULT_LIMIT)
-          new(scope: scope, key: key, limit: limit).result
+        def call(key:, scope: LlmCostTracker::Ledger::Call.all, limit: DEFAULT_LIMIT)
+          new(scope: scope, key: key, limit: limit)
         end
       end
 
+      attr_reader :limit
+
       def initialize(scope:, key:, limit:)
         @scope = scope
-        @key = LlmCostTracker::TagKey.validate!(key, error_class: LlmCostTracker::InvalidFilterError)
-        @limit = normalized_limit(limit)
-        @connection = LlmCostTracker::LlmApiCall.connection
+        @key = LlmCostTracker::Tags::Key.validate!(key, error_class: LlmCostTracker::InvalidFilterError)
+        limit = limit.to_i
+        @limit = limit.positive? ? [limit, DEFAULT_LIMIT].min : DEFAULT_LIMIT
       end
 
-      def result
-        counts = summary_counts
-
-        TagBreakdownResult.new(
-          rows: rows,
-          total_calls: counts.fetch(:total_calls),
-          tagged_calls: counts.fetch(:tagged_calls),
-          distinct_values: counts.fetch(:distinct_values),
-          limit: limit
-        )
+      def rows
+        @rows ||= scope.klass.find_by_sql(rows_sql)
       end
 
-      private
+      def total_calls
+        summary_counts.total_calls.to_i
+      end
 
-      attr_reader :scope, :key, :limit, :connection
+      def tagged_calls
+        summary_counts.tagged_calls.to_i
+      end
 
-      def rows
-        connection.select_all(rows_sql).map do |row|
-          calls = row["calls_count"].to_i
-          total_cost = row["total_cost_sum"].to_f
-          TagBreakdownRow.new(
-            value: LlmCostTracker::LlmApiCall.tag_value_label(row["tag_value"]),
-            calls: calls,
-            total_cost: total_cost,
-            average_cost_per_call: calls.positive? ? total_cost / calls : 0.0
-          )
-        end
+      def distinct_values
+        summary_counts.distinct_values.to_i
       end
 
+      private
+
+      attr_reader :scope, :key
+
       def summary_counts
-        row = connection.select_one(summary_sql) || {}
-        {
-          total_calls: row["total_calls"].to_i,
-          tagged_calls: row["tagged_calls"].to_i,
-          distinct_values: row["distinct_values"].to_i
-        }
+        @summary_counts ||= scope.klass.find_by_sql(summary_sql).first
       end
 
       def rows_sql
         <<~SQL.squish
-          SELECT #{tag_expression} AS tag_value,
-                 COUNT(*) AS calls_count,
-                 COALESCE(SUM(sub.total_cost), 0) AS total_cost_sum
+          SELECT #{tag_expression} AS value,
+                 COUNT(*) AS calls,
+                 COALESCE(SUM(sub.total_cost), 0) AS total_cost,
+                 COALESCE(SUM(sub.total_cost), 0) / NULLIF(COUNT(*), 0) AS average_cost_per_call
           FROM (#{scope.to_sql}) AS sub
           WHERE #{tag_present_predicate}
           GROUP BY #{tag_expression}
-          ORDER BY total_cost_sum DESC, calls_count DESC, tag_value ASC
+          ORDER BY total_cost DESC, calls DESC, value ASC
           LIMIT #{limit}
         SQL
       end
@@ -100,12 +72,7 @@ module LlmCostTracker
       end
 
       def tag_expression
-        @tag_expression ||= LlmCostTracker::LlmApiCall.tag_value_expression(key, table_name: "sub")
-      end
-
-      def normalized_limit(value)
-        value = value.to_i
-        value.positive? ? [value, DEFAULT_LIMIT].min : DEFAULT_LIMIT
+        @tag_expression ||= LlmCostTracker::Ledger::Call.tag_value_expression(key, table_name: "sub")
       end
     end
   end

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

@@ -2,32 +2,24 @@
 
 module LlmCostTracker
   module Dashboard
-    TagKeyRow = Data.define(:key, :calls_count, :distinct_values)
-
     class TagKeyExplorer
       DEFAULT_LIMIT = 100
 
       class << self
-        def call(scope: LlmCostTracker::LlmApiCall.all, limit: DEFAULT_LIMIT)
+        def call(scope: LlmCostTracker::Ledger::Call.all, limit: DEFAULT_LIMIT)
           new(scope: scope, limit: limit).rows
         end
       end
 
       def initialize(scope:, limit:)
         @scope = scope
-        @connection = LlmCostTracker::LlmApiCall.connection
-        @limit = normalized_limit(limit)
+        @connection = LlmCostTracker::Ledger::Call.connection
+        limit = limit.to_i
+        @limit = limit.positive? ? [limit, DEFAULT_LIMIT].min : DEFAULT_LIMIT
       end
 
       def rows
-        results = @connection.select_all(build_sql).to_a
-        results.map do |row|
-          TagKeyRow.new(
-            key: row["key"].to_s,
-            calls_count: row["calls_count"].to_i,
-            distinct_values: row["distinct_values"].to_i
-          )
-        end
+        scope.klass.find_by_sql(build_sql)
       rescue StandardError => e
         LlmCostTracker::Logging.warn("Tag key discovery failed (#{connection.adapter_name}): #{e.class}: #{e.message}")
         []
@@ -42,10 +34,10 @@ module LlmCostTracker
       end
 
       def build_sql
-        return postgresql_sql if ActiveRecordAdapter.postgresql?(connection)
-        return mysql_sql if ActiveRecordAdapter.mysql?(connection)
+        return postgresql_sql if Ledger::Schema::Adapter.postgresql?(connection)
+        return mysql_sql if Ledger::Schema::Adapter.mysql?(connection)
 
-        ActiveRecordAdapter.ensure_supported!(connection)
+        Ledger::Schema::Adapter.ensure_supported!(connection)
       end
 
       def mysql_sql
@@ -82,11 +74,6 @@ module LlmCostTracker
           LIMIT #{limit}
         SQL
       end
-
-      def normalized_limit(value)
-        value = value.to_i
-        value.positive? ? [value, DEFAULT_LIMIT].min : DEFAULT_LIMIT
-      end
     end
   end
 end

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

@@ -8,7 +8,7 @@ module LlmCostTracker
       DEFAULT_DAYS = 30
 
       class << self
-        def call(scope: LlmCostTracker::LlmApiCall.all, from: nil, to: Date.current)
+        def call(scope: LlmCostTracker::Ledger::Call.all, from: nil, to: Date.current)
           new(scope: scope, from: from, to: to).points
         end
       end

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

@@ -2,24 +2,13 @@
 
 module LlmCostTracker
   module Dashboard
-    TopModel = Data.define(
-      :provider,
-      :model,
-      :calls,
-      :total_cost,
-      :average_cost_per_call,
-      :input_tokens,
-      :output_tokens,
-      :average_latency_ms
-    )
-
     class TopModels
       DEFAULT_LIMIT = 5
       SORT_OPTIONS = %w[cost calls avg_cost latency].freeze
       DEFAULT_SORT = "cost"
 
       class << self
-        def call(scope: LlmCostTracker::LlmApiCall.all, limit: DEFAULT_LIMIT, sort: DEFAULT_SORT)
+        def call(scope: LlmCostTracker::Ledger::Call.all, limit: DEFAULT_LIMIT, sort: DEFAULT_SORT)
           new(scope: scope, limit: limit, sort: sort).rows
         end
       end
@@ -31,28 +20,6 @@ module LlmCostTracker
       end
 
       def rows
-        grouped_rows.map do |row|
-          calls = row.calls_count.to_i
-          total_cost = row.total_cost_sum.to_f
-
-          TopModel.new(
-            provider: row.provider,
-            model: row.model,
-            calls: calls,
-            total_cost: total_cost,
-            average_cost_per_call: calls.positive? ? total_cost / calls : 0.0,
-            input_tokens: row.input_tokens_sum.to_i,
-            output_tokens: row.output_tokens_sum.to_i,
-            average_latency_ms: average_latency(row)
-          )
-        end
-      end
-
-      private
-
-      attr_reader :scope, :limit, :sort
-
-      def grouped_rows
         scope
           .group(:provider, :model)
           .select(selects)
@@ -60,6 +27,10 @@ module LlmCostTracker
           .then { |r| limit ? r.limit(limit) : r }
       end
 
+      private
+
+      attr_reader :scope, :limit, :sort
+
       def order_sql
         case sort
         when "calls"
@@ -67,8 +38,6 @@ module LlmCostTracker
         when "avg_cost"
           "COALESCE(SUM(total_cost), 0) / NULLIF(COUNT(*), 0) DESC"
         when "latency"
-          return "COALESCE(SUM(total_cost), 0) DESC" unless scope.klass.latency_column?
-
           "CASE WHEN AVG(latency_ms) IS NULL THEN 1 ELSE 0 END ASC, AVG(latency_ms) DESC"
         else
           "COALESCE(SUM(total_cost), 0) DESC"
@@ -79,20 +48,16 @@ module LlmCostTracker
         columns = [
           "provider",
           "model",
-          "COUNT(*) AS calls_count",
-          "COALESCE(SUM(total_cost), 0) AS total_cost_sum",
-          "COALESCE(SUM(input_tokens), 0) AS input_tokens_sum",
-          "COALESCE(SUM(output_tokens), 0) AS output_tokens_sum"
+          "COUNT(*) AS calls",
+          "COALESCE(SUM(total_cost), 0) AS total_cost",
+          "COALESCE(SUM(total_cost), 0) / NULLIF(COUNT(*), 0) AS average_cost_per_call",
+          "COALESCE(SUM(total_tokens), 0) AS total_tokens",
+          "COALESCE(SUM(input_tokens), 0) AS input_tokens",
+          "COALESCE(SUM(output_tokens), 0) AS output_tokens",
+          "AVG(latency_ms) AS average_latency_ms"
         ]
-        columns << "AVG(latency_ms) AS average_latency" if scope.klass.latency_column?
         columns.join(", ")
       end
-
-      def average_latency(row)
-        return nil unless scope.klass.latency_column?
-
-        row.average_latency&.to_f
-      end
     end
   end
 end

data/app/views/llm_cost_tracker/calls/index.html.erb

@@ -34,15 +34,13 @@
                        id: "lct-model" %>
       </div>
 
-      <% if LlmCostTracker::LlmApiCall.stream_column? %>
-        <div class="lct-field">
-          <label for="lct-stream">Stream</label>
-          <%= select_tag :stream,
-                         options_for_select(LlmCostTracker::DashboardFilterHelper::STREAM_FILTER_OPTIONS, params[:stream]),
-                         include_blank: "All calls",
-                         id: "lct-stream" %>
-        </div>
-      <% end %>
+      <div class="lct-field">
+        <label for="lct-stream">Stream</label>
+        <%= select_tag :stream,
+                       options_for_select(LlmCostTracker::DashboardFilterHelper::STREAM_FILTER_OPTIONS, params[:stream]),
+                       include_blank: "All calls",
+                       id: "lct-stream" %>
+      </div>
 
       <div class="lct-field">
         <label for="lct-sort">Sort</label>
@@ -51,9 +49,9 @@
                          [["Recent first", ""],
                           ["Most expensive", "expensive"],
                           ["Largest input", "input"],
-                          ["Largest output", "output"]] +
-                         (@latency_available ? [["Slowest", "slow"]] : []) +
-                         [["Unknown pricing only", "unknown_pricing"]],
+                          ["Largest output", "output"],
+                          ["Slowest", "slow"],
+                          ["Unknown pricing only", "unknown_pricing"]],
                          @sort
                        ),
                        id: "lct-sort" %>
@@ -104,9 +102,7 @@
             <th class="lct-num">Output</th>
             <th class="lct-num">Total</th>
             <th class="lct-num">Cost</th>
-            <% if @latency_available %>
-              <th class="lct-num">Latency</th>
-            <% end %>
+            <th class="lct-num">Latency</th>
             <th>Tags</th>
             <th></th>
           </tr>
@@ -121,9 +117,7 @@
               <td class="lct-num"><%= format_tokens(call.output_tokens) %></td>
               <td class="lct-num"><%= format_tokens(call.total_tokens) %></td>
               <td class="lct-num<%= ' lct-num-muted' if call.total_cost.nil? %>"><%= optional_money(call.total_cost) %></td>
-              <% if @latency_available %>
-                <td class="lct-num<%= ' lct-num-muted' if call.latency_ms.nil? %>"><%= call.latency_ms ? "#{number(call.latency_ms)}ms" : "n/a" %></td>
-              <% end %>
+              <td class="lct-num<%= ' lct-num-muted' if call.latency_ms.nil? %>"><%= call.latency_ms ? "#{number(call.latency_ms)}ms" : "n/a" %></td>
               <td><%= render "llm_cost_tracker/shared/tag_chips", tags: call.parsed_tags %></td>
               <td><%= link_to "Details", call_path(call), class: "lct-button lct-button-secondary lct-button-compact" %></td>
             </tr>

data/app/views/llm_cost_tracker/calls/show.html.erb

@@ -1,11 +1,17 @@
-<% token_segments = [
-  { label: "Input", value: @call.input_tokens, formatted_value: format_tokens(@call.input_tokens), css_class: "lct-stack-fill-input" },
-  { label: "Output", value: @call.output_tokens, formatted_value: format_tokens(@call.output_tokens), css_class: "lct-stack-fill-output" }
-] %>
-<% cost_segments = [
-  { label: "Input", value: @call.input_cost, formatted_value: optional_money(@call.input_cost), css_class: "lct-stack-fill-input" },
-  { label: "Output", value: @call.output_cost, formatted_value: optional_money(@call.output_cost), css_class: "lct-stack-fill-output" }
-] %>
+<% priced_components = token_usage_stack_components %>
+<% token_segments = priced_components.map do |component|
+  token_key = component.fetch(:token_key)
+  value = @call.has_attribute?(token_key) ? @call[token_key] : 0
+  { label: component.fetch(:label), value: value, formatted_value: format_tokens(value), css_class: component.fetch(:css_class) }
+end %>
+<% cost_segments = [] %>
+<% unless @call.total_cost.nil? %>
+  <% cost_segments = priced_components.map do |component|
+    cost_key = component.fetch(:cost_key)
+    value = @call.has_attribute?(cost_key) ? @call[cost_key] : nil
+    { label: component.fetch(:label), value: value, formatted_value: optional_money(value), css_class: component.fetch(:css_class) }
+  end %>
+<% end %>
 
 <section class="lct-panel">
   <p class="lct-muted"><%= link_to "Back to calls", calls_path %></p>
@@ -34,12 +40,10 @@
         <span class="lct-call-summary-label">Total tokens</span>
         <strong><%= format_tokens(@call.total_tokens) %></strong>
       </div>
-      <% if @latency_available %>
-        <div class="lct-call-summary-item">
-          <span class="lct-call-summary-label">Latency</span>
-          <strong><%= @call.latency_ms ? "#{optional_number(@call.latency_ms)}ms" : "n/a" %></strong>
-        </div>
-      <% end %>
+      <div class="lct-call-summary-item">
+        <span class="lct-call-summary-label">Latency</span>
+        <strong><%= @call.latency_ms ? "#{optional_number(@call.latency_ms)}ms" : "n/a" %></strong>
+      </div>
     </div>
   </div>
 
@@ -73,10 +77,8 @@
       <dt>Pricing Status</dt>
       <dd><%= pricing_status(@call) %></dd>
 
-      <% if LlmCostTracker::LlmApiCall.provider_response_id_column? %>
-        <dt>Provider Response ID</dt>
-        <dd><%= @call.provider_response_id.presence || "n/a" %></dd>
-      <% end %>
+      <dt>Provider Response ID</dt>
+      <dd><%= @call.provider_response_id.presence || "n/a" %></dd>
 
       <% if @call.has_attribute?("created_at") %>
         <dt>Created At</dt>
@@ -90,28 +92,24 @@
     </dl>
 
     <dl class="lct-dl">
-      <dt>Input Tokens</dt>
-      <dd><%= format_tokens(@call.input_tokens) %></dd>
-
-      <dt>Output Tokens</dt>
-      <dd><%= format_tokens(@call.output_tokens) %></dd>
+      <% priced_components.each do |component| %>
+        <dt><%= component.fetch(:label).titleize %> Tokens</dt>
+        <dd><%= format_tokens(@call[component.fetch(:token_key)]) %></dd>
+      <% end %>
 
       <dt>Total Tokens</dt>
       <dd><%= format_tokens(@call.total_tokens) %></dd>
 
-      <dt>Input Cost</dt>
-      <dd><%= optional_money(@call.input_cost) %></dd>
-
-      <dt>Output Cost</dt>
-      <dd><%= optional_money(@call.output_cost) %></dd>
+      <% priced_components.each do |component| %>
+        <dt><%= component.fetch(:label).titleize %> Cost</dt>
+        <dd><%= optional_money(@call[component.fetch(:cost_key)]) %></dd>
+      <% end %>
 
       <dt>Total Cost</dt>
       <dd><%= optional_money(@call.total_cost) %></dd>
 
-      <% if @latency_available %>
-        <dt>Latency</dt>
-        <dd><%= @call.latency_ms ? "#{optional_number(@call.latency_ms)}ms" : "n/a" %></dd>
-      <% end %>
+      <dt>Latency</dt>
+      <dd><%= @call.latency_ms ? "#{optional_number(@call.latency_ms)}ms" : "n/a" %></dd>
     </dl>
   </div>
 </section>

data/app/views/llm_cost_tracker/dashboard/index.html.erb

@@ -29,15 +29,13 @@
                        id: "lct-overview-model" %>
       </div>
 
-      <% if LlmCostTracker::LlmApiCall.stream_column? %>
-        <div class="lct-field">
-          <label for="lct-overview-stream">Stream</label>
-          <%= select_tag :stream,
-                         options_for_select(LlmCostTracker::DashboardFilterHelper::STREAM_FILTER_OPTIONS, params[:stream]),
-                         include_blank: "All calls",
-                         id: "lct-overview-stream" %>
-        </div>
-      <% end %>
+      <div class="lct-field">
+        <label for="lct-overview-stream">Stream</label>
+        <%= select_tag :stream,
+                       options_for_select(LlmCostTracker::DashboardFilterHelper::STREAM_FILTER_OPTIONS, params[:stream]),
+                       include_blank: "All calls",
+                       id: "lct-overview-stream" %>
+      </div>
 
       <div class="lct-filter-actions">
         <button class="lct-button" type="submit">Apply</button>
@@ -49,7 +47,7 @@
   <%= render "llm_cost_tracker/shared/active_filters", chips: active_tag_filters, clear_path: root_path %>
 </section>
 
-<% if @stats.total_calls.zero? %>
+<% if @stats.total_calls.to_i.zero? %>
   <section class="lct-panel lct-empty">
     <h2 class="lct-state-title">No LLM calls yet</h2>
     <p class="lct-state-copy">Tracked requests will appear here after your application records its first LLM API call.</p>
@@ -58,11 +56,11 @@
     </div>
   </section>
 <% else %>
-  <% if @stats.unknown_pricing_count.positive? %>
+  <% if @stats.unknown_pricing_count.to_i.positive? %>
     <aside class="lct-banner lct-banner-warning" role="status">
       <div class="lct-banner-body">
         <p class="lct-banner-title">
-          <%= number(@stats.unknown_pricing_count) %> call<%= "s" unless @stats.unknown_pricing_count == 1 %> missing pricing
+          <%= number(@stats.unknown_pricing_count) %> call<%= "s" unless @stats.unknown_pricing_count.to_i == 1 %> missing pricing
           <span class="lct-banner-muted">· <%= percent(coverage_percent(@stats.unknown_pricing_count, @stats.total_calls)) %> of the slice</span>
         </p>
         <p class="lct-banner-copy">Totals undercount until every model has a known price. Update <code class="lct-code">pricing_overrides</code> or <code class="lct-code">prices_file</code> to fix.</p>
@@ -76,18 +74,18 @@
       <div class="lct-banner-body">
         <p class="lct-banner-title">
           Spend anomaly detected
-          <span class="lct-banner-muted">· <code class="lct-code"><%= @spend_anomaly.model %></code> on <%= @spend_anomaly.day.strftime("%b %-d") %></span>
+          <span class="lct-banner-muted">· <code class="lct-code"><%= @spend_anomaly.fetch(:model) %></code> on <%= @spend_anomaly.fetch(:day).strftime("%b %-d") %></span>
         </p>
         <p class="lct-banner-copy">
-          <% if @spend_anomaly.ratio %>
-            <%= number_with_precision(@spend_anomaly.ratio, precision: 1) %>× its prior 7-day average in this slice
+          <% if @spend_anomaly.fetch(:ratio) %>
+            <%= number_with_precision(@spend_anomaly.fetch(:ratio), precision: 1) %>× its prior 7-day average in this slice
           <% else %>
-            <%= money(@spend_anomaly.latest_spend) %> after seven quiet days in this slice
+            <%= money(@spend_anomaly.fetch(:latest_spend)) %> after seven quiet days in this slice
           <% end %>
         </p>
       </div>
       <%= link_to "Review calls →",
-                  calls_path(current_query(provider: @spend_anomaly.provider, model: @spend_anomaly.model, from: @to_date.iso8601, to: @to_date.iso8601, page: nil, per: nil, format: nil)),
+                  calls_path(current_query(provider: @spend_anomaly.fetch(:provider), model: @spend_anomaly.fetch(:model), from: @to_date.iso8601, to: @to_date.iso8601, page: nil, per: nil, format: nil)),
                   class: "lct-button lct-button-secondary" %>
     </aside>
   <% end %>
@@ -125,8 +123,8 @@
 
       </div>
 
-      <% if @stats.monthly_budget_status %>
-        <% budget = @stats.monthly_budget_status %>
+      <% if @monthly_budget_status %>
+        <% budget = @monthly_budget_status %>
         <% fill_mod = budget_fill_modifier(budget[:percent_used]) %>
         <% projected_marker = [[budget[:projected_percent_used].to_f, 0.0].max, 100.0].min %>
         <% projected_delta = budget[:projected_delta].to_f %>