llm_cost_tracker 0.7.2 → 0.8.0

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

@@ -1,45 +1,98 @@
 # 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(:model, :calls, :share_percent)
+      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)
-          model = scope.klass
-          scope.unscope(:order).select(aggregate_selects(scope, model:)).take
+        def call(scope: LlmCostTracker::Call.all)
+          scope.unscope(:order).select(aggregate_selects(scope)).take
+        end
+
+        def summary(stats)
+          total = stats.total_calls.to_i
+          unknown_pricing_count = stats.unknown_pricing_count.to_i
+          untagged_calls_count = stats.untagged_calls_count.to_i
+          missing_latency_count = stats.missing_latency_count.to_i
+          streaming_count = stats.streaming_count.to_i
+          streaming_missing_usage = stats.streaming_missing_usage_count.to_i
+          missing_provider_response_id_count = stats.missing_provider_response_id_count.to_i
+          calls_with_pricing = total - unknown_pricing_count
+          tagged_calls = total - untagged_calls_count
+          calls_with_latency = total - missing_latency_count
+          streams_with_usage = streaming_count - streaming_missing_usage
+          calls_with_provider_response_id = total - missing_provider_response_id_count
+
+          Summary.new(
+            total, unknown_pricing_count, untagged_calls_count, missing_latency_count, streaming_count,
+            streaming_missing_usage, 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)
+        def unknown_pricing_by_model(scope, total_calls:)
           scope.unknown_pricing
                .group(:model)
                .order(Arel.sql("COUNT(*) DESC"))
                .select("model, COUNT(*) AS calls")
                .limit(10)
+               .map do |row|
+                 calls = row.calls.to_i
+                 UnknownPricingRow.new(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
@@ -57,6 +110,21 @@ 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 hidden_output_summary(stats)
           output_tokens = stats.output_tokens.to_i
           return unless output_tokens.positive?
@@ -70,12 +138,29 @@ module LlmCostTracker
 
         private
 
-        def aggregate_selects(scope, model:)
+        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",
-            "#{tagged_calls_sql(model)} AS tagged_calls_count",
-            "COUNT(*) - #{tagged_calls_sql(model)} AS untagged_calls_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",
             "#{conditional_count_sql('stream')} AS streaming_count",
             "#{streaming_missing_usage_select} AS streaming_missing_usage_count",
@@ -93,11 +178,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
@@ -109,6 +194,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 +221,12 @@ module LlmCostTracker
           conditional_count_sql(predicate)
         end
 
-        def tagged_calls_sql(model)
-          table = model.quoted_table_name
-          column = "#{table}.#{model.connection.quote_column_name('tags')}"
+        def tagged_calls_sql(scope)
+          calls_table = scope.klass.quoted_table_name
+          tags_table = LlmCostTracker::CallTag.quoted_table_name
 
-          if Ledger::Schema::Adapter.postgresql?(model.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
+          "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

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
 

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

@@ -4,9 +4,10 @@ module LlmCostTracker
   module Dashboard
     class TagBreakdown
       DEFAULT_LIMIT = 100
+      Row = Data.define(:value, :calls, :total_cost, :average_cost_per_call, :share_percent)
 
       class << self
-        def call(key:, scope: LlmCostTracker::Ledger::Call.all, limit: DEFAULT_LIMIT)
+        def call(key:, scope: LlmCostTracker::Call.all, limit: DEFAULT_LIMIT)
           new(scope: scope, key: key, limit: limit)
         end
       end
@@ -21,7 +22,19 @@ module LlmCostTracker
       end
 
       def rows
-        @rows ||= scope.klass.find_by_sql(rows_sql)
+        @rows ||= begin
+          total = tagged_calls
+          scope.klass.find_by_sql(rows_sql).map do |row|
+            calls = row.calls.to_i
+            Row.new(
+              value: row.value,
+              calls: calls,
+              total_cost: row.total_cost,
+              average_cost_per_call: row.average_cost_per_call,
+              share_percent: percentage(calls, total)
+            )
+          end
+        end
       end
 
       def total_calls
@@ -46,13 +59,14 @@ module LlmCostTracker
 
       def rows_sql
         <<~SQL.squish
-          SELECT #{tag_expression} AS value,
+          SELECT #{tag_value_column} 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
+          INNER JOIN #{call_tag_table} t ON t.llm_cost_tracker_call_id = sub.id AND t.#{quote_column('key')} = #{quoted_key}
           WHERE #{tag_present_predicate}
-          GROUP BY #{tag_expression}
+          GROUP BY #{tag_value_column}
           ORDER BY total_cost DESC, calls DESC, value ASC
           LIMIT #{limit}
         SQL
@@ -61,18 +75,37 @@ module LlmCostTracker
       def summary_sql
         <<~SQL.squish
           SELECT COUNT(*) AS total_calls,
-                 COALESCE(SUM(CASE WHEN #{tag_present_predicate} THEN 1 ELSE 0 END), 0) AS tagged_calls,
-                 COUNT(DISTINCT CASE WHEN #{tag_present_predicate} THEN #{tag_expression} END) AS distinct_values
+                 COUNT(t.#{quote_column('value')}) 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}
         SQL
       end
 
       def tag_present_predicate
-        "#{tag_expression} IS NOT NULL AND #{tag_expression} != ''"
+        "#{tag_value_column} IS NOT NULL AND #{tag_value_column} != ''"
+      end
+
+      def tag_value_column
+        "t.#{quote_column('value')}"
+      end
+
+      def call_tag_table
+        LlmCostTracker::CallTag.quoted_table_name
       end
 
-      def tag_expression
-        @tag_expression ||= LlmCostTracker::Ledger::Call.tag_value_expression(key, table_name: "sub")
+      def quote_column(name)
+        scope.connection.quote_column_name(name)
+      end
+
+      def quoted_key
+        scope.connection.quote(key)
+      end
+
+      def percentage(numerator, denominator)
+        return 0.0 unless denominator.positive?
+
+        (numerator / denominator.to_f) * 100.0
       end
     end
   end

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

@@ -6,14 +6,14 @@ module LlmCostTracker
       DEFAULT_LIMIT = 100
 
       class << self
-        def call(scope: LlmCostTracker::Ledger::Call.all, limit: DEFAULT_LIMIT)
+        def call(scope: LlmCostTracker::Call.all, limit: DEFAULT_LIMIT)
           new(scope: scope, limit: limit).rows
         end
       end
 
       def initialize(scope:, limit:)
         @scope = scope
-        @connection = LlmCostTracker::Ledger::Call.connection
+        @connection = LlmCostTracker::Call.connection
         limit = limit.to_i
         @limit = limit.positive? ? [limit, DEFAULT_LIMIT].min : DEFAULT_LIMIT
       end
@@ -29,50 +29,27 @@ module LlmCostTracker
 
       attr_reader :scope, :connection, :limit
 
-      def subquery
-        scope.to_sql
-      end
-
       def build_sql
-        return postgresql_sql if Ledger::Schema::Adapter.postgresql?(connection)
-        return mysql_sql if Ledger::Schema::Adapter.mysql?(connection)
-
-        Ledger::Schema::Adapter.ensure_supported!(connection)
-      end
+        tags_table = LlmCostTracker::CallTag.quoted_table_name
 
-      def mysql_sql
         <<~SQL.squish
-          SELECT jt.key AS key,
+          SELECT t.#{key_column} AS #{key_column},
                  COUNT(*) AS calls_count,
-                 COUNT(DISTINCT JSON_UNQUOTE(JSON_EXTRACT(sub.tags, CONCAT('$.', JSON_QUOTE(jt.key))))) AS distinct_values
-          FROM (#{subquery}) AS sub
-          JOIN JSON_TABLE(
-            COALESCE(JSON_KEYS(sub.tags), JSON_ARRAY()),
-            '$[*]' COLUMNS(
-              key VARCHAR(255) PATH '$'
-            )
-          ) AS jt
-          WHERE sub.tags IS NOT NULL
-            AND sub.tags != ''
-          GROUP BY jt.key
+                 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
+          GROUP BY t.#{key_column}
           ORDER BY calls_count DESC
           LIMIT #{limit}
         SQL
       end
 
-      def postgresql_sql
-        <<~SQL.squish
-          SELECT key,
-                 COUNT(*) AS calls_count,
-                 COUNT(DISTINCT (sub.tags::jsonb)->>key) AS distinct_values
-          FROM (#{subquery}) AS sub,
-               jsonb_object_keys(sub.tags::jsonb) AS key
-          WHERE sub.tags IS NOT NULL
-            AND sub.tags::jsonb <> '{}'::jsonb
-          GROUP BY key
-          ORDER BY calls_count DESC
-          LIMIT #{limit}
-        SQL
+      def key_column
+        connection.quote_column_name("key")
+      end
+
+      def value_column
+        connection.quote_column_name("value")
       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::Ledger::Call.all, from: nil, to: Date.current)
+        def call(scope: LlmCostTracker::Call.all, from: nil, to: Date.current)
           new(scope: scope, from: from, to: to).points
         end
       end