llm_cost_tracker 0.14.0 → 0.14.2

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

@@ -13,7 +13,6 @@ module LlmCostTracker
                               :missing_latency_count,
                               :streaming_count,
                               :streaming_missing_usage,
-                              :missing_provider_response_id_count,
                               :calls_with_pricing,
                               :tagged_calls,
                               :calls_with_latency,
@@ -52,7 +51,7 @@ module LlmCostTracker
           return nil unless Budget::PerTag.columns?
           return nil unless LlmCostTracker::CallTag.exists?
 
-          unseen = budgeted.keys.reject { |key| LlmCostTracker::CallTag.exists?(key: key) }
+          unseen = budgeted.keys.reject { |key| LlmCostTracker::CallTag.where(key: key).where.not(value: "").exists? }
           return nil if unseen.empty?
 
           UnseenBudgetTags.new(keys: unseen)
@@ -79,7 +78,6 @@ module LlmCostTracker
             missing_latency_count,
             streaming_count,
             streaming_missing_usage,
-            missing_provider_response_id_count,
             calls_with_pricing,
             tagged_calls,
             calls_with_latency,
@@ -142,7 +140,6 @@ module LlmCostTracker
             token_value = stats[component.token_key].to_i
 
             {
-              price_key: component.key,
               token_key: component.token_key,
               cost_key: component.cost_key,
               token_value: token_value,
@@ -154,7 +151,6 @@ module LlmCostTracker
 
           rows + [
             {
-              price_key: nil,
               token_key: :hidden_output_tokens,
               cost_key: nil,
               token_value: stats.hidden_output_tokens.to_i,
@@ -178,7 +174,7 @@ module LlmCostTracker
                         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)
+          Usage::Catalog.costs_by_component(rows)
         end
 
         def streaming_health_rows(scope, total_streaming:)
@@ -221,13 +217,6 @@ module LlmCostTracker
 
         private
 
-        def index_costs_by_component(rows)
-          rows.each_with_object({}) do |(kind, direction, cache_state, cost), accumulator|
-            component = Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
-            accumulator[component.key] = cost if component
-          end
-        end
-
         def percentage(numerator, denominator)
           return 0.0 unless denominator.positive?
 
@@ -239,7 +228,6 @@ module LlmCostTracker
           selects = [
             "COUNT(*) AS total_calls",
             "#{conditional_count_sql(unknown_pricing)} 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",
             "#{conditional_count_sql('stream')} AS streaming_count",
@@ -301,7 +289,8 @@ module LlmCostTracker
           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)"
+            "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)"
         end
       end
     end

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

@@ -5,20 +5,23 @@ require "date"
 module LlmCostTracker
   module Dashboard
     class Filter
+      MAX_TAG_FILTERS = 10
+      MATCH_NOTHING = Arel.sql("1 = 0")
       STREAM_FILTER_OPTIONS = [
         ["Streaming only", "yes"],
         ["Non-streaming only", "no"]
       ].freeze
 
       class << self
-        def call(scope: LlmCostTracker::Call.all, params: {})
-          new(scope: scope, params: params).relation
+        def call(scope: LlmCostTracker::Call.all, params: {}, tags: {})
+          new(scope: scope, params: params, tags: tags).relation
         end
       end
 
-      def initialize(scope:, params:)
+      def initialize(scope:, params:, tags: {})
         @scope = scope
         @params = LlmCostTracker::Dashboard::Params.to_hash(params).symbolize_keys
+        @extra_tags = tags
       end
 
       def relation
@@ -27,44 +30,44 @@ module LlmCostTracker
         filtered_scope = apply_exact_filter(filtered_scope, :provider)
         filtered_scope = apply_exact_filter(filtered_scope, :model)
         filtered_scope = apply_stream_filter(filtered_scope)
-        filtered_scope = apply_usage_source_filter(filtered_scope)
+        filtered_scope = apply_exact_filter(filtered_scope, :usage_source)
         apply_tag_filters(filtered_scope)
       end
 
       private
 
-      attr_reader :scope, :params
+      attr_reader :scope, :params, :extra_tags
 
       def apply_date_filters(relation)
-        from_date = Dashboard::DateRange.parse(params, :from)
-        to_date = Dashboard::DateRange.parse(params, :to)
-        Dashboard::DateRange.validate!(from: from_date, to: to_date)
-
-        default_range = Dashboard::DateRange.call(params: params)
-        from_date ||= default_range.from
-        to_date ||= default_range.to
+        Dashboard::DateRange.validate!(from: Dashboard::DateRange.parse(params, :from),
+                                       to: Dashboard::DateRange.parse(params, :to))
+        range = Dashboard::DateRange.call(params: params)
 
         relation
-          .where(tracked_at: from_date.beginning_of_day..)
-          .where(tracked_at: ..to_date.end_of_day)
+          .where(tracked_at: range.from.beginning_of_day..)
+          .where(tracked_at: ..range.to.end_of_day)
       end
 
       def apply_exact_filter(relation, key)
-        value = normalized_string(params[key])
+        value = normalized_string(params[key], key)
         return relation if value.nil?
 
-        relation.where(key => value)
+        matchable?([value]) ? relation.where(key => value) : relation.where(MATCH_NOTHING)
       end
 
       def apply_tag_filters(relation)
-        tags = tag_params
+        tags = tag_params.merge(extra_tags)
         return relation if tags.empty?
+        if tags.size > MAX_TAG_FILTERS
+          raise LlmCostTracker::InvalidFilterError,
+                "at most #{MAX_TAG_FILTERS} tag filters are allowed, got #{tags.size}"
+        end
 
-        relation.by_tags(tags)
+        matchable?(tags.values) ? relation.by_tags(tags) : relation.where(MATCH_NOTHING)
       end
 
       def apply_stream_filter(relation)
-        value = normalized_string(params[:stream])
+        value = normalized_string(params[:stream], :stream)
         return relation if value.nil?
 
         case value.downcase
@@ -74,28 +77,24 @@ module LlmCostTracker
         end
       end
 
-      def apply_usage_source_filter(relation)
-        value = normalized_string(params[:usage_source])
-        return relation if value.nil?
-
-        relation.where(usage_source: value)
-      end
-
       def tag_params
         tags = LlmCostTracker::Dashboard::Params.to_hash(params[:tag])
 
         tags.each_with_object({}) do |(key, value), normalized|
-          value = normalized_string(value)
+          value = normalized_string(value, "tag filter value")
           next if value.nil?
 
           normalized[LlmCostTracker::Tags::Key.validate!(key, error_class: LlmCostTracker::InvalidFilterError)] = value
         end
       end
 
-      def normalized_string(value)
-        return nil if value.nil?
+      def matchable?(values)
+        values.none? { |value| value.include?("\0") } ||
+          !LlmCostTracker::Ledger::Schema::Adapter.postgresql?(scope.connection)
+      end
 
-        value.to_s.strip.presence
+      def normalized_string(value, name)
+        LlmCostTracker::Dashboard::Params.scalar(value, name).strip.presence
       end
     end
   end

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

@@ -19,11 +19,8 @@ module LlmCostTracker
         )
       end
 
-      def self.integer_param(params, key, default:, min:, max: nil)
-        value = Integer(params[key], 10)
-        value = [value, min].max
-        value = [value, max].min if max
-        value
+      def self.integer_param(params, key, default:, min:, max:)
+        Integer(params[key], 10).clamp(min, max)
       rescue ArgumentError, TypeError
         default
       end

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

@@ -3,6 +3,8 @@
 module LlmCostTracker
   module Dashboard
     module Params
+      QUERY_KEYS = %i[from to provider model tag tag_value stream usage_source cost_status sort dir page per].freeze
+
       class << self
         def to_hash(value)
           return {} if value.nil?
@@ -17,6 +19,14 @@ module LlmCostTracker
           {}
         end
 
+        def scalar(value, name)
+          if value.is_a?(Hash) || value.is_a?(Array) || value.respond_to?(:to_unsafe_h)
+            raise InvalidFilterError, "#{name} must be a single value"
+          end
+
+          value.to_s
+        end
+
         def tag_query(value)
           to_hash(value).each_with_object({}) do |(key, tag_value), tags|
             key = key.to_s

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

@@ -63,9 +63,10 @@ module LlmCostTracker
       end
 
       def build_rows(prices)
+        today = Time.now.utc.to_date.iso8601
         rows = prices.map do |key, rates|
           provider, model = split_key(key.to_s)
-          Row.new(provider: provider, model: model, rates: rates)
+          Row.new(provider: provider, model: model, rates: Pricing::Matcher.prices_on(rates, today))
         end
         rows.sort_by { |row| [row.provider || "~", row.model] }
       end

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

@@ -59,7 +59,7 @@ module LlmCostTracker
           .where(tracked_at: window)
           .where.not(total_cost: nil)
           .group(:provider, :model)
-          .group_by_period(:day)
+          .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

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

@@ -4,7 +4,6 @@ module LlmCostTracker
   module Dashboard
     class TagBreakdown
       DEFAULT_LIMIT = 100
-      SORT_OPTIONS = %w[value calls cost avg_cost].freeze
       DEFAULT_DIRECTIONS = { "value" => "asc", "calls" => "desc", "cost" => "desc", "avg_cost" => "desc" }.freeze
       Row = Data.define(:value, :calls, :total_cost, :average_cost_per_call, :share_percent)
 
@@ -21,7 +20,7 @@ module LlmCostTracker
         @key = LlmCostTracker::Tags::Key.validate!(key, error_class: LlmCostTracker::InvalidFilterError)
         limit = limit.to_i
         @limit = limit.positive? ? [limit, DEFAULT_LIMIT].min : DEFAULT_LIMIT
-        @sort = SORT_OPTIONS.include?(sort.to_s) ? sort.to_s : "cost"
+        @sort = DEFAULT_DIRECTIONS.key?(sort.to_s) ? sort.to_s : "cost"
         @direction = Sort::DIRECTIONS.include?(direction.to_s) ? direction.to_s : DEFAULT_DIRECTIONS[@sort]
       end
 
@@ -89,7 +88,7 @@ module LlmCostTracker
       def summary_sql
         <<~SQL.squish
           SELECT COUNT(*) AS total_calls,
-                 COUNT(t.#{quote_column('value')}) AS tagged_calls,
+                 COUNT(CASE WHEN #{tag_present_predicate} THEN 1 END) AS tagged_calls,
                  COUNT(DISTINCT CASE WHEN #{tag_present_predicate} THEN #{tag_value_column} END) AS distinct_values
           FROM (#{scope.to_sql}) AS sub
           LEFT OUTER JOIN #{call_tag_table} t ON t.llm_cost_tracker_call_id = sub.id AND t.#{quote_column('key')} = #{quoted_key}

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

@@ -38,6 +38,7 @@ module LlmCostTracker
                  COUNT(DISTINCT t.#{value_column}) AS distinct_values
           FROM (#{scope.to_sql}) AS sub
           INNER JOIN #{tags_table} t ON t.llm_cost_tracker_call_id = sub.id
+          WHERE t.#{value_column} != ''
           GROUP BY t.#{key_column}
           ORDER BY calls_count DESC
           LIMIT #{limit}

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

@@ -5,18 +5,16 @@ require "date"
 module LlmCostTracker
   module Dashboard
     class TimeSeries
-      DEFAULT_DAYS = 30
-
       class << self
-        def call(scope: LlmCostTracker::Call.all, from: nil, to: Date.current)
+        def call(from:, to:, scope: LlmCostTracker::Call.all)
           new(scope: scope, from: from, to: to).points
         end
       end
 
       def initialize(scope:, from:, to:)
         @scope = scope
+        @from = from.to_date
         @to = to.to_date
-        @from = from ? from.to_date : (@to - (DEFAULT_DAYS - 1))
       end
 
       def points
@@ -35,7 +33,7 @@ module LlmCostTracker
       def scoped_costs
         scope
           .where(tracked_at: from.beginning_of_day..to.end_of_day)
-          .group_by_period(:day)
+          .group_by_period(:day, time_zone: Time.zone)
           .sum(:total_cost)
           .transform_values(&:to_f)
       end

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

@@ -4,7 +4,6 @@ module LlmCostTracker
   module Dashboard
     class TopModels
       DEFAULT_LIMIT = 5
-      SORT_OPTIONS = %w[cost calls avg_cost latency tokens provider name].freeze
       DEFAULT_SORT = "cost"
       DEFAULT_DIRECTIONS = {
         "provider" => "asc",
@@ -43,7 +42,7 @@ module LlmCostTracker
       def initialize(scope:, limit:, sort: DEFAULT_SORT, direction: nil)
         @scope = scope
         @limit = limit
-        @sort = SORT_OPTIONS.include?(sort.to_s) ? sort.to_s : DEFAULT_SORT
+        @sort = DEFAULT_DIRECTIONS.key?(sort.to_s) ? sort.to_s : DEFAULT_SORT
         @direction = Sort::DIRECTIONS.include?(direction.to_s) ? direction.to_s : DEFAULT_DIRECTIONS[@sort]
       end
 

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

@@ -5,13 +5,10 @@
   value = @call[token_key]
   { label: component.fetch(:label), value: value, formatted_value: number_with_delimiter(value), css_class: component.fetch(:css_class) }
 end %>
-<% cost_segments = [] %>
-<% unless @call.total_cost.nil? %>
-  <% cost_segments = priced_components.map do |component|
-    value = line_item_costs_by_component[component.fetch(:price_key)]
-    { label: component.fetch(:label), value: value, formatted_value: optional_money(value), css_class: component.fetch(:css_class) }
-  end %>
-<% end %>
+<% cost_segments = priced_components.map do |component|
+  value = line_item_costs_by_component[component.fetch(:price_key)]
+  { label: component.fetch(:label), value: value, formatted_value: optional_money(value), css_class: component.fetch(:css_class) }
+end %>
 <% service_line_items = @call.line_items.reject { |li| li.unit == "token" }.sort_by(&:position) %>
 
 <p class="lct-breadcrumb-back"><%= link_to "← All calls", calls_path %></p>
@@ -84,22 +81,11 @@ end %>
         <dd><%= content_tag(:code, @call.provider_response_id, class: "lct-code-id") %></dd>
       </div>
     <% end %>
-    <% if @call.provider_project_id.present? %>
-      <div class="lct-meta-strip-item">
-        <dt>Project ID</dt>
-        <dd><%= content_tag(:code, LlmCostTracker::Dashboard::Masking.mask_value(:provider_project_id, @call.provider_project_id), class: "lct-code-id") %></dd>
-      </div>
-    <% end %>
-    <% if @call.provider_api_key_id.present? %>
-      <div class="lct-meta-strip-item">
-        <dt>API Key ID</dt>
-        <dd><%= content_tag(:code, LlmCostTracker::Dashboard::Masking.mask_value(:provider_api_key_id, @call.provider_api_key_id), class: "lct-code-id") %></dd>
-      </div>
-    <% end %>
-    <% if @call.provider_workspace_id.present? %>
+    <% { provider_project_id: "Project ID", provider_api_key_id: "API Key ID", provider_workspace_id: "Workspace ID" }.each do |attribute, label| %>
+      <% next if @call[attribute].blank? %>
       <div class="lct-meta-strip-item">
-        <dt>Workspace ID</dt>
-        <dd><%= content_tag(:code, LlmCostTracker::Dashboard::Masking.mask_value(:provider_workspace_id, @call.provider_workspace_id), class: "lct-code-id") %></dd>
+        <dt><%= label %></dt>
+        <dd><%= content_tag(:code, LlmCostTracker::Dashboard::Masking.mask_value(attribute, @call[attribute]), class: "lct-code-id") %></dd>
       </div>
     <% end %>
   </dl>

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

@@ -271,7 +271,7 @@
         <h2 class="lct-panel-title">Incomplete pricing by model</h2>
         <span class="lct-panel-meta"><%= link_to "View calls →", calls_path(current_query(cost_status: "incomplete", sort: nil)) %></span>
       </div>
-      <p class="lct-panel-intro">These models have line items without configured rates, so totals undercount (a full row is missing all rates; a partial row has some line items priced and others not). After the next price refresh or a <code>pricing_overrides</code> update, run <code>bin/rails llm_cost_tracker:backfill_unknown_pricing</code> to recompute these calls.</p>
+      <p class="lct-panel-intro">These models have line items without configured rates, so totals undercount (a full row is missing all rates; a partial row has some line items priced and others not). After the next price refresh or a <code>pricing_overrides</code> update, run <code>bin/rails llm_cost_tracker:backfill_unknown_pricing</code> to recompute these calls. A partial call is left as recorded when a rate it already used has changed since.</p>
 
       <div class="lct-table-wrap">
         <table class="lct-tbl">

data/app/views/llm_cost_tracker/shared/_bar.html.erb

@@ -1,5 +1,3 @@
-<% variant_class = local_assigns[:variant] == "budget" ? " lct-budget-fill" : "" %>
-
 <div class="lct-bar-track" aria-hidden="true">
-  <div data-lct-style="<%= inline_style("width: #{bar_width(value, max)}") %>" class="lct-bar-fill<%= variant_class %>"></div>
+  <div data-lct-style="<%= inline_style("width: #{bar_width(value, max)}") %>" class="lct-bar-fill"></div>
 </div>

data/app/views/llm_cost_tracker/shared/_filter_pill_date.html.erb

@@ -1,5 +1,3 @@
-<% extra_hidden = local_assigns.fetch(:extra_hidden, {}) %>
-<% extra_except = local_assigns.fetch(:extra_except, []) %>
 <details class="lct-filter-pop" name="lct-filter">
   <summary class="lct-filter-pill">
     <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="4" width="18" height="18" rx="2"/><path d="M16 2v4M8 2v4M3 10h18"/></svg>
@@ -8,8 +6,7 @@
     <svg class="lct-chev" width="10" height="6" viewBox="0 0 10 6" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 1l4 4 4-4"/></svg>
   </summary>
   <%= form_with url: path, method: :get, local: true, html: { class: "lct-filter-pop-body" } do %>
-    <% extra_hidden.each do |k, v| %><%= hidden_field_tag k, v %><% end %>
-    <%= hidden_query_fields(current_query.except(:from, :to, :page, :per, *extra_except)) %>
+    <%= hidden_query_fields(current_query.except(:from, :to, :page, :per)) %>
     <div class="lct-filter-pop-field"><label for="lct-filter-from">From</label><input type="date" name="from" id="lct-filter-from" value="<%= @from_date.iso8601 %>"></div>
     <div class="lct-filter-pop-field"><label for="lct-filter-to">To</label><input type="date" name="to" id="lct-filter-to" value="<%= @to_date.iso8601 %>"></div>
     <button type="submit" class="lct-button lct-button-primary">Apply</button>

data/app/views/llm_cost_tracker/shared/_filter_pill_model.html.erb

@@ -1,5 +1,3 @@
-<% extra_hidden = local_assigns.fetch(:extra_hidden, {}) %>
-<% extra_except = local_assigns.fetch(:extra_except, []) %>
 <% active = params[:model].presence %>
 <details class="lct-filter-pop" name="lct-filter">
   <summary class="lct-filter-pill <%= 'lct-active' if active %>">
@@ -9,8 +7,7 @@
     <svg class="lct-chev" width="10" height="6" viewBox="0 0 10 6" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 1l4 4 4-4"/></svg>
   </summary>
   <%= form_with url: path, method: :get, local: true, html: { class: "lct-filter-pop-body" } do %>
-    <% extra_hidden.each do |k, v| %><%= hidden_field_tag k, v %><% end %>
-    <%= hidden_query_fields(current_query.except(:model, :page, :per, *extra_except)) %>
+    <%= hidden_query_fields(current_query.except(:model, :page, :per)) %>
     <div class="lct-filter-pop-field">
       <label for="lct-filter-model">Model</label>
       <%= select_tag :model, options_for_select(filter_options_for(:model), active), include_blank: "All models", id: "lct-filter-model" %>

data/app/views/llm_cost_tracker/shared/_filter_pill_provider.html.erb

@@ -1,5 +1,3 @@
-<% extra_hidden = local_assigns.fetch(:extra_hidden, {}) %>
-<% extra_except = local_assigns.fetch(:extra_except, []) %>
 <% active = params[:provider].presence %>
 <details class="lct-filter-pop" name="lct-filter">
   <summary class="lct-filter-pill <%= 'lct-active' if active %>">
@@ -9,8 +7,7 @@
     <svg class="lct-chev" width="10" height="6" viewBox="0 0 10 6" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 1l4 4 4-4"/></svg>
   </summary>
   <%= form_with url: path, method: :get, local: true, html: { class: "lct-filter-pop-body" } do %>
-    <% extra_hidden.each do |k, v| %><%= hidden_field_tag k, v %><% end %>
-    <%= hidden_query_fields(current_query.except(:provider, :page, :per, *extra_except)) %>
+    <%= hidden_query_fields(current_query.except(:provider, :page, :per)) %>
     <div class="lct-filter-pop-field">
       <label for="lct-filter-provider">Provider</label>
       <%= select_tag :provider, options_for_select(filter_options_for(:provider), active), include_blank: "All providers", id: "lct-filter-provider" %>

data/app/views/llm_cost_tracker/shared/_filter_pill_stream.html.erb

@@ -1,5 +1,3 @@
-<% extra_hidden = local_assigns.fetch(:extra_hidden, {}) %>
-<% extra_except = local_assigns.fetch(:extra_except, []) %>
 <% active = params[:stream].presence %>
 <% display_value = case active when "yes" then "Streaming" when "no" then "Non-streaming" else "All" end %>
 <details class="lct-filter-pop" name="lct-filter">
@@ -10,8 +8,7 @@
     <svg class="lct-chev" width="10" height="6" viewBox="0 0 10 6" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 1l4 4 4-4"/></svg>
   </summary>
   <%= form_with url: path, method: :get, local: true, html: { class: "lct-filter-pop-body" } do %>
-    <% extra_hidden.each do |k, v| %><%= hidden_field_tag k, v %><% end %>
-    <%= hidden_query_fields(current_query.except(:stream, :page, :per, *extra_except)) %>
+    <%= hidden_query_fields(current_query.except(:stream, :page, :per)) %>
     <div class="lct-filter-pop-field">
       <label for="lct-filter-stream">Stream</label>
       <%= select_tag :stream, options_for_select(LlmCostTracker::Dashboard::Filter::STREAM_FILTER_OPTIONS, active), include_blank: "All calls", id: "lct-filter-stream" %>

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

@@ -5,9 +5,9 @@
   <h2 class="lct-page-title">Tag: <code class="lct-code-id"><%= params[:key] %></code> = <code class="lct-code-id"><%= @value %></code></h2>
 
   <div class="lct-filter-row">
-    <%= render "llm_cost_tracker/shared/filter_pill_date", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
-    <%= render "llm_cost_tracker/shared/filter_pill_provider", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
-    <%= render "llm_cost_tracker/shared/filter_pill_model", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
+    <%= render "llm_cost_tracker/shared/filter_pill_date", path: form_url %>
+    <%= render "llm_cost_tracker/shared/filter_pill_provider", path: form_url %>
+    <%= render "llm_cost_tracker/shared/filter_pill_model", path: form_url %>
 
     <% if params[:provider].present? || params[:model].present? %>
       <%= link_to "× Clear filters", tag_path(params[:key], current_query(provider: nil, model: nil, page: nil)), class: "lct-filter-clear" %>
@@ -35,7 +35,7 @@
       </div>
       <div class="lct-stat">
         <div class="lct-stat-head"><p class="lct-stat-label">Avg cost / call</p></div>
-        <p class="lct-stat-value"><%= money(@value_calls.positive? ? @value_total_cost / @value_calls : 0) %></p>
+        <p class="lct-stat-value"><%= money(@value_total_cost / @value_calls) %></p>
       </div>
     </div>
 
@@ -44,7 +44,7 @@
         <h2 class="lct-panel-title">Spend over time</h2>
         <span class="lct-panel-meta"><%= link_to "View calls →", calls_path(calls_query_for_tag(key: @key, value: @value)) %></span>
       </div>
-      <%= render "llm_cost_tracker/shared/spend_chart", series: @value_points, comparison_series: [] %>
+      <%= render "llm_cost_tracker/shared/spend_chart", series: @value_points %>
     </section>
   <% end %>
 
@@ -107,6 +107,7 @@
           </tr>
         </thead>
         <tbody>
+          <% drilldown_allowed = tag_drilldown_allowed?(params[:key]) %>
           <% @breakdown.rows.each do |row| %>
             <tr>
               <td><code class="lct-code-id"><%= row.value %></code></td>
@@ -117,6 +118,8 @@
               <td class="lct-num">
                 <% if row.value == "(untagged)" %>
                   <span class="lct-num-muted">n/a</span>
+                <% elsif !drilldown_allowed %>
+                  <span class="lct-num-muted">tag filter limit</span>
                 <% else %>
                   <%= link_to "Trend", tag_path(params[:key], current_query.merge(tag_value: row.value)), class: "lct-page-link" %>
                   <%= link_to "Calls", calls_path(calls_query_for_tag(key: params[:key], value: row.value)), class: "lct-page-link" %>

data/config/routes.rb

@@ -4,7 +4,12 @@ LlmCostTracker::Engine.routes.draw do
   root "dashboard#index"
   resources :calls, only: %i[index show], constraints: { id: /\d+/ }, defaults: { format: :html }
   resources :models, only: :index
-  resources :tags, only: %i[index show], param: :key, format: false
+  resources :tags,
+            only: %i[index show],
+            param: :key,
+            format: false,
+            constraints: { key: %r{[^/]+} },
+            defaults: { format: :html }
   get "data_quality", to: "data_quality#index", as: :data_quality
   get "pricing", to: "pricing#index", as: :pricing
 

data/lib/llm_cost_tracker/budget/per_tag.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../ledger/isolation"
 require_relative "../ledger/schema/adapter"
 require_relative "../ledger/tags/encoding"
 
@@ -29,7 +30,7 @@ module LlmCostTracker
         end
 
         def blocking?
-          active? && configured.each_value.any? { |entry| behavior_for(entry) == :block_requests }
+          configured.each_value.any? { |entry| behavior_for(entry) == :block_requests } && active?
         end
 
         def rules_for(tags, blocking_only: false)
@@ -37,13 +38,13 @@ module LlmCostTracker
 
           normalized = (tags || {}).to_h.transform_keys(&:to_s)
           configured.filter_map do |key, entry|
-            raw = normalized[key]
-            next if raw.nil?
+            value = Ledger::Tags::Encoding.encode(normalized[key])
+            next if value.empty?
             next if blocking_only && behavior_for(entry) != :block_requests
 
             Rule.new(
               key: key,
-              value: Ledger::Tags::Encoding.encode(raw),
+              value: value,
               windows: entry[:windows],
               behavior: behavior_for(entry),
               on_exceeded: on_exceeded_for(entry)
@@ -52,20 +53,28 @@ module LlmCostTracker
         end
 
         def rules_for_events(events)
-          events.each_with_object({}) do |event, grouped|
+          events.select(&:total_cost).each_with_object({}) do |event, grouped|
             rules_for(event.tags).each { |rule| (grouped[rule] ||= []) << event }
           end
         end
 
         def spend(key, value, window, time:)
-          spend_by_value(key, [value], window, window_start(window, time)).fetch(value, 0).to_d
+          spend_by_value(key, [value], window, window_start(window, time)).fetch(value, [0]).first.to_d
         end
 
-        def spend_by_value(key, values, window, bucket)
+        def spend_by_value(key, values, window, bucket, upto = nil)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          totals = LlmCostTracker::CallTag
-                   .where(key: key, value: values, TIME_COLUMN => window_range(window, bucket))
-                   .group(:value).sum(COST_COLUMN)
+          range = window_range(window, bucket)
+          upto_sum = LlmCostTracker::CallTag.sanitize_sql_array(
+            ["SUM(CASE WHEN #{TIME_COLUMN} <= ? THEN #{COST_COLUMN} ELSE 0 END)", upto || range.end]
+          )
+          totals = Ledger::Isolation.guard(LlmCostTracker::CallTag) do
+            LlmCostTracker::CallTag
+              .where(key: key, value: values, TIME_COLUMN => range)
+              .group(:value)
+              .pluck(:value, Arel.sql("SUM(#{COST_COLUMN})"), Arel.sql(upto_sum))
+              .to_h { |value, *sums| [value, sums.map(&:to_d)] }
+          end
           warn_slow_read(key, window, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at)
           totals
         end
@@ -88,7 +97,8 @@ module LlmCostTracker
         end
 
         def columns?
-          (LlmCostTracker::CallTag.column_names & [COST_COLUMN, TIME_COLUMN]).size == 2
+          LlmCostTracker::CallTag.table_exists? &&
+            (LlmCostTracker::CallTag.column_names & [COST_COLUMN, TIME_COLUMN]).size == 2
         end
 
         private