llm_cost_tracker 0.14.1 → 0.15.0

data/app/models/llm_cost_tracker/call.rb

@@ -45,7 +45,10 @@ module LlmCostTracker
       def already_recorded?(provider:, provider_response_id:)
         return false if provider_response_id.to_s.empty?
 
-        Ledger::Isolation.guard(self) { where(provider: provider, provider_response_id: provider_response_id).exists? }
+        Ledger::Isolation.guard(self) do
+          where(provider: provider, provider_response_id: provider_response_id)
+            .where.not(usage_source: Usage::Source::UNKNOWN).exists?
+        end
       end
 
       def by_tag(key, value) = by_tags(key => value)
@@ -66,8 +69,8 @@ module LlmCostTracker
 
       def cost_by_tag(key, limit: nil)
         cost = qualified(:total_cost)
-        label = Ledger::Tags::Breakdown.label_sql(connection)
-        raw_value = Ledger::Tags::Breakdown.raw_value_sql(connection)
+        label = Ledger::Tags::Breakdown.label_sql(lease_connection)
+        raw_value = Ledger::Tags::Breakdown.raw_value_sql(lease_connection)
         relation = Ledger::Tags::Breakdown.join_relation(self, key)
                                           .select("#{label} AS name", "COALESCE(SUM(#{cost}), 0) AS total_cost")
                                           .group(Arel.sql(label))
@@ -86,8 +89,14 @@ module LlmCostTracker
 
       def latency_by_provider = group(:provider).average(:latency_ms).transform_values(&:to_f)
 
-      def group_by_period(period, column: :tracked_at)
-        group(Arel.sql(period_group_expression(period, column: column)))
+      def group_by_period(period, column: :tracked_at, time_zone: nil)
+        column = column.to_s
+        raise ArgumentError, "invalid period column: #{column.inspect}" unless column_names.include?(column)
+
+        bucket = Ledger::Schema::Adapter.period_bucket_sql(
+          lease_connection, period, qualified(column), time_zone: time_zone
+        )
+        group(Arel.sql(bucket))
       end
 
       def daily_costs(days: 30)
@@ -97,7 +106,7 @@ module LlmCostTracker
       end
 
       def qualified(column)
-        "#{quoted_table_name}.#{connection.quote_column_name(column)}"
+        "#{quoted_table_name}.#{lease_connection.quote_column_name(column)}"
       end
 
       private
@@ -109,17 +118,6 @@ module LlmCostTracker
         relation = relation.limit(limit) if limit
         relation
       end
-
-      def period_group_expression(period, column:)
-        Ledger::Schema::Adapter.period_bucket_sql(connection, period, period_column_expression(column))
-      end
-
-      def period_column_expression(column)
-        column = column.to_s
-        return "#{quoted_table_name}.#{connection.quote_column_name(column)}" if column_names.include?(column)
-
-        raise ArgumentError, "invalid period column: #{column.inspect}"
-      end
     end
 
     def tag_pairs

data/app/models/llm_cost_tracker/call_rollup.rb

@@ -34,15 +34,15 @@ module LlmCostTracker
       end
 
       def increment_on_duplicate
-        return Arel.sql(mysql_increment_sql) if Ledger::Schema::Adapter.mysql?(connection)
-        return Arel.sql(postgres_increment_sql) if Ledger::Schema::Adapter.postgresql?(connection)
+        return Arel.sql(mysql_increment_sql) if Ledger::Schema::Adapter.mysql?(lease_connection)
+        return Arel.sql(postgres_increment_sql) if Ledger::Schema::Adapter.postgresql?(lease_connection)
 
-        Ledger::Schema::Adapter.ensure_supported!(connection)
+        Ledger::Schema::Adapter.ensure_supported!(lease_connection)
       end
 
       def postgres_increment_sql
-        total = connection.quote_column_name("total_cost")
-        updated = connection.quote_column_name("updated_at")
+        total = lease_connection.quote_column_name("total_cost")
+        updated = lease_connection.quote_column_name("updated_at")
         "#{total} = #{quoted_table_name}.#{total} + excluded.#{total}, #{updated} = excluded.#{updated}"
       end
 
@@ -51,7 +51,7 @@ module LlmCostTracker
       end
 
       def increment_unique_by
-        return unless connection.supports_insert_conflict_target?
+        return unless lease_connection.supports_insert_conflict_target?
 
         %i[period period_start currency provider]
       end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module CallOrder
+      NATURAL_DIRECTIONS = {
+        "tracked_at" => "desc",
+        "provider" => "asc",
+        "model" => "asc",
+        "input" => "desc",
+        "output" => "desc",
+        "cost" => "desc",
+        "latency" => "desc"
+      }.freeze
+      NEWEST_FIRST = { tracked_at: :desc, id: :desc }.freeze
+      COST_NULLS_LAST = Arel.sql("CASE WHEN total_cost IS NULL THEN 1 ELSE 0 END ASC")
+      LATENCY_NULLS_LAST = Arel.sql("CASE WHEN latency_ms IS NULL THEN 1 ELSE 0 END ASC")
+      ORDERS = {
+        "tracked_at" => ->(dir) { [{ tracked_at: dir, id: dir }] },
+        "provider" => ->(dir) { [{ provider: dir, model: :asc, **NEWEST_FIRST }] },
+        "model" => ->(dir) { [{ model: dir, **NEWEST_FIRST }] },
+        "input" => ->(dir) { [{ input_tokens: dir, **NEWEST_FIRST }] },
+        "output" => ->(dir) { [{ output_tokens: dir, **NEWEST_FIRST }] },
+        "cost" => ->(dir) { [COST_NULLS_LAST, { total_cost: dir, **NEWEST_FIRST }] },
+        "latency" => ->(dir) { [LATENCY_NULLS_LAST, { latency_ms: dir, **NEWEST_FIRST }] }
+      }.freeze
+
+      def self.call(scope, sort:, direction:)
+        choice = Sort.resolve(
+          sort, direction.to_s.downcase, natural_directions: NATURAL_DIRECTIONS, fallback: "tracked_at"
+        )
+        scope.order(*ORDERS.fetch(choice.column).call(choice.direction.to_sym))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+
+module LlmCostTracker
+  module Dashboard
+    class CallsExport
+      MYSQL_HINT = "NO_SKIP_SCAN(llm_cost_tracker_calls)"
+      FORMULA_PREFIXES = ["=", "+", "-", "@", "\t", "\r"].freeze
+      MASKED_FIELDS = %i[provider_api_key_id provider_workspace_id provider_project_id].freeze
+      TEXT_FIELDS = %i[provider model provider_response_id cost_status].freeze
+      FIELDS = [
+        :tracked_at, :provider, :model, *Usage::TokenUsage.members, :total_cost, :cost_status, :pricing_snapshot,
+        :latency_ms, :provider_response_id, :provider_project_id, :provider_api_key_id, :provider_workspace_id,
+        :batch, :tags
+      ].freeze
+
+      def self.call(relation, limit:, batch_size:)
+        new(relation, limit: limit, batch_size: batch_size).to_s
+      end
+
+      def initialize(relation, limit:, batch_size:)
+        @relation = relation
+        @limit = limit
+        @batch_size = batch_size
+      end
+
+      def to_s
+        CSV.generate do |csv|
+          csv << FIELDS.map(&:to_s)
+          each_call { |call| csv << FIELDS.map { |field| value(field, call) } }
+        end
+      end
+
+      private
+
+      attr_reader :relation, :limit, :batch_size
+
+      def each_call(&block)
+        scope = relation.limit(limit)
+        scope = scope.optimizer_hints(MYSQL_HINT) if Ledger::Schema::Adapter.mysql?(scope.lease_connection)
+        scope.pluck(:id).each_slice(batch_size) do |ids|
+          calls = LlmCostTracker::Call.where(id: ids).preload(:tag_records).index_by(&:id)
+          calls.values_at(*ids).compact.each(&block)
+        end
+      end
+
+      def value(field, call)
+        case field
+        when :tracked_at then call.tracked_at.utc.iso8601
+        when *MASKED_FIELDS then formula_safe(Masking.mask_value(field, call[field]))
+        when *TEXT_FIELDS then formula_safe(call[field])
+        when :pricing_snapshot then formula_safe(Hash(call.pricing_snapshot).deep_stringify_keys.to_json)
+        when :tags then formula_safe(call.tag_pairs.to_json)
+        else call[field]
+        end
+      end
+
+      def formula_safe(value)
+        return if value.nil?
+
+        string = value.to_s
+        FORMULA_PREFIXES.include?(string.lstrip[0]) ? "'#{string}" : string
+      end
+    end
+  end
+end

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,37 +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,
-                              :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::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
@@ -48,54 +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?
-
-          unseen = budgeted.keys.reject { |key| LlmCostTracker::CallTag.exists?(key: key) }
-          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
+          return nil if budgeted.empty? || !Budget::PerTag.columns? || !LlmCostTracker::CallTag.exists?
 
-          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)
-          )
+          unseen = budgeted.keys.reject { |key| LlmCostTracker::CallTag.where(key: key).where.not(value: "").exists? }
+          UnseenBudgetTags.new(keys: unseen) unless unseen.empty?
         end
 
         def unknown_pricing_by_model(scope, total_calls:)
@@ -109,103 +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
-
             {
-              price_key: component.key,
               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 + [
-            {
-              price_key: nil,
-              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)"))
-          index_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)
@@ -219,89 +114,39 @@ module LlmCostTracker
           }
         end
 
-        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?
-
-          (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",
-            "#{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",
-            "#{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) 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