llm_cost_tracker 0.10.0 → 0.12.0

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

@@ -1,19 +1,31 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/billing/components"
-require "llm_cost_tracker/ledger/schema/adapter"
-
 module LlmCostTracker
   module Dashboard
-    class DataQuality
+    module DataQuality
       UnknownPricingRow = ::Data.define(:provider, :model, :calls, :share_percent)
       StreamingHealthRow = ::Data.define(:provider, :streams, :with_usage, :unknown, :unknown_share)
-      Summary = ::Data.define(:total, :unknown_pricing_count, :untagged_calls_count, :missing_latency_count,
-                              :streaming_count, :streaming_missing_usage, :missing_provider_response_id_count,
-                              :calls_with_pricing, :tagged_calls, :calls_with_latency, :streams_with_usage,
-                              :calls_with_provider_response_id, :unknown_pricing_share, :untagged_share,
-                              :missing_latency_share, :streaming_share, :streaming_missing_usage_share,
-                              :cost_coverage, :tag_coverage, :latency_coverage, :stream_coverage,
+      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
@@ -36,14 +48,28 @@ module LlmCostTracker
           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)
+            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
 
@@ -55,7 +81,9 @@ module LlmCostTracker
                .limit(10)
                .map do |row|
                  calls = row.calls.to_i
-                 UnknownPricingRow.new(provider: row.provider, model: row.model, calls: calls,
+                 UnknownPricingRow.new(provider: row.provider,
+                                       model: row.model,
+                                       calls: calls,
                                        share_percent: percentage(calls, total_calls))
                end
         end
@@ -85,7 +113,7 @@ module LlmCostTracker
         def usage_rows(stats, component_costs: {})
           billable_tokens = stats.billable_tokens.to_f
 
-          rows = Billing::Components::TOKEN_PRICED.map do |component|
+          rows = Usage::Catalog.token_priced.map do |component|
             token_value = stats[component.token_key].to_i
 
             {
@@ -118,7 +146,8 @@ module LlmCostTracker
                  .where(unit: "token")
                  .joins(:call)
                  .merge(scope.unscope(:select, :order, :group))
-                 .group("#{line_item_table}.kind", "#{line_item_table}.direction",
+                 .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"),
@@ -130,7 +159,7 @@ module LlmCostTracker
         def streaming_health_rows(scope, total_streaming:)
           return [] unless total_streaming.positive?
 
-          unknown_predicate = "usage_source = 'unknown' OR usage_source IS NULL"
+          unknown_predicate = unknown_usage_source_predicate(scope)
           rows = scope.unscope(:select, :order, :group)
                       .where(stream: true)
                       .group(:provider)
@@ -169,11 +198,7 @@ module LlmCostTracker
 
         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
+            component = Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
             accumulator[component.key] = cost if component
           end
         end
@@ -185,14 +210,15 @@ module LlmCostTracker
         end
 
         def aggregate_selects(scope)
+          unknown_pricing = Charges::CostStatus.unknown_pricing_sql
           selects = [
             "COUNT(*) AS total_calls",
-            "#{conditional_count_sql(unknown_pricing_predicate(scope))} AS unknown_pricing_count",
+            "#{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} AS streaming_missing_usage_count",
+            "#{streaming_missing_usage_select(scope)} AS streaming_missing_usage_count",
             "#{provider_response_id_select} AS missing_provider_response_id_count"
           ]
 
@@ -207,13 +233,13 @@ module LlmCostTracker
         end
 
         def usage_sum_columns
-          Billing::Components::TOKEN_PRICED.map(&:token_key) + [:hidden_output_tokens]
+          Usage::Catalog.token_priced.map(&:token_key) + [:hidden_output_tokens]
         end
 
         def billable_tokens_select(scope)
-          Billing::Components::TOKEN_PRICED
-            .map { |component| column_sum(scope, component.token_key) }
-            .join(" + ")
+          Usage::Catalog.token_priced
+                        .map { |component| column_sum(scope, component.token_key) }
+                        .join(" + ")
         end
 
         def hidden_output_share_select(scope)
@@ -223,13 +249,9 @@ 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(', ')})"
+        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)
@@ -240,9 +262,8 @@ module LlmCostTracker
           "COALESCE(SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END), 0)"
         end
 
-        def streaming_missing_usage_select
-          predicate = "stream AND (usage_source = 'unknown' OR usage_source IS NULL)"
-          conditional_count_sql(predicate)
+        def streaming_missing_usage_select(scope)
+          conditional_count_sql("stream AND (#{unknown_usage_source_predicate(scope)})")
         end
 
         def provider_response_id_select

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

@@ -5,6 +5,11 @@ require "date"
 module LlmCostTracker
   module Dashboard
     class Filter
+      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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module Masking
+      SENSITIVE_KEYS = %w[provider_api_key_id provider_workspace_id provider_project_id].freeze
+      MASK_TAIL_LENGTH = 4
+
+      def self.mask_value(key, value)
+        string = value.to_s
+        return string unless SENSITIVE_KEYS.include?(key.to_s)
+        return string if string.length <= MASK_TAIL_LENGTH
+
+        "***#{string[-MASK_TAIL_LENGTH, MASK_TAIL_LENGTH]}"
+      end
+
+      def self.mask_hash(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), masked|
+          masked[key] = case value
+                        when Hash then mask_hash(value)
+                        when Array then value.map { |entry| entry.is_a?(Hash) ? mask_hash(entry) : entry }
+                        else
+                          mask_value(key, value)
+                        end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module MonthlyBudget
+      module_function
+
+      def 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[month], time: now).fetch(:month)
+        elapsed_seconds = now - month_start
+        total_seconds = month_end - month_start
+        projected_spent = if spent.zero? || !elapsed_seconds.positive?
+                            spent
+                          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,
+          spent: spent,
+          percent_used: percent_used,
+          projected_spent: projected_spent,
+          projected_percent_used: projected_percent_used,
+          projected_delta: projected_delta,
+          projection_end_label: month_end.strftime("%b %-d"),
+          fill_modifier: 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
+
+      def clamped_percent(value)
+        value.clamp(0.0, 100.0)
+      end
+
+      def 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
+end

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

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/ledger"
-
 module LlmCostTracker
   module Dashboard
-    class OverviewStats
+    module OverviewStats
       class << self
         def call(scope: LlmCostTracker::Call.all, previous_scope: nil)
           return scope.select(aggregate_selects).take unless previous_scope
@@ -16,48 +14,6 @@ module LlmCostTracker
                .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[month], time: now).fetch(:month)
-          elapsed_seconds = now - month_start
-          total_seconds = month_end - month_start
-          projected_spent = if spent.zero? || !elapsed_seconds.positive?
-                              spent
-                            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,
-            spent: spent,
-            percent_used: percent_used,
-            projected_spent: projected_spent,
-            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(table_name: nil, previous: false)
@@ -69,11 +25,10 @@ module LlmCostTracker
             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
+          predicate = LlmCostTracker::Charges::CostStatus.unknown_pricing_sql(
+            total_cost: total_cost, cost_status: cost_status
+          )
+          unknown_pricing_sql = "SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END)"
           selects = [
             "COUNT(*) AS total_calls",
             "COALESCE(SUM(#{total_cost}), 0) AS total_cost",
@@ -85,10 +40,6 @@ module LlmCostTracker
           selects.join(", ")
         end
 
-        def connection
-          LlmCostTracker::Call.connection
-        end
-
         def previous_selects(previous)
           unless previous
             return [
@@ -125,23 +76,6 @@ module LlmCostTracker
             .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
   end

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

@@ -6,6 +6,7 @@ module LlmCostTracker
       DEFAULT_PER = 50
       MAX_PER = 200
       MIN_PAGE = 1
+      MIN_PER = 1
 
       attr_reader :page, :per
 
@@ -13,7 +14,7 @@ module LlmCostTracker
         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)
+          per: integer_param(params, :per, default: DEFAULT_PER, min: MIN_PER, max: MAX_PER)
         )
       end
 
@@ -33,10 +34,6 @@ module LlmCostTracker
         freeze
       end
 
-      def limit
-        per
-      end
-
       def offset
         (page - 1) * per
       end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    class PricingOverview
+      SOURCES = %i[overrides file bundled].freeze
+      RATE_COLUMNS = %w[input output cache_read_input cache_write_input batch_input batch_output].freeze
+      Row = Data.define(:provider, :model, :rates)
+
+      SOURCE_NAME = { overrides: "pricing_overrides", file: "prices_file", bundled: "bundled" }.freeze
+      LABEL = { overrides: "Overrides", file: "Custom file", bundled: "Bundled" }.freeze
+      private_constant :SOURCE_NAME, :LABEL
+
+      class << self
+        def call
+          new.call
+        end
+      end
+
+      def call
+        sources = SOURCES.each_with_object({}) do |key, acc|
+          source = sources_by_name.fetch(SOURCE_NAME.fetch(key))
+          acc[key] = present(key, source) unless source.prices.empty?
+        end
+        {
+          sources: sources,
+          effective_source: sources.keys.first || :bundled
+        }
+      end
+
+      private
+
+      def sources_by_name
+        @sources_by_name ||= Pricing::Registry.sources.to_h { |source| [source.name, source] }
+      end
+
+      def present(key, source)
+        {
+          label: LABEL.fetch(key),
+          subtitle: subtitle_for(key),
+          updated_at: updated_at_for(key),
+          currency: source.currency,
+          rows: build_rows(source.prices)
+        }
+      end
+
+      def subtitle_for(key)
+        case key
+        when :overrides then "config.pricing_overrides"
+        when :file then LlmCostTracker.configuration.prices_file.to_s
+        when :bundled then "ships with the gem"
+        end
+      end
+
+      def updated_at_for(key)
+        case key
+        when :file
+          path = LlmCostTracker.configuration.prices_file
+          Pricing::Registry.file_metadata(path)["updated_at"] || Pricing::Registry.prices_file_mtime_iso
+        when :bundled
+          Pricing::Registry.metadata["updated_at"]
+        end
+      end
+
+      def build_rows(prices)
+        rows = prices.map do |key, rates|
+          provider, model = split_key(key.to_s)
+          Row.new(provider: provider, model: model, rates: rates)
+        end
+        rows.sort_by { |row| [row.provider || "~", row.model] }
+      end
+
+      def split_key(key)
+        provider, model = key.split("/", 2)
+        return [provider, model] if model
+
+        [nil, provider]
+      end
+    end
+  end
+end

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

@@ -1,53 +1,19 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/ledger/schema/calls"
-require "llm_cost_tracker/ledger/schema/call_line_items"
-require "llm_cost_tracker/ledger/schema/call_tags"
-require "llm_cost_tracker/ledger/schema/call_rollups"
-
 module LlmCostTracker
   module Dashboard
     module SetupState
       SetupRequired = Data.define(:message, :details)
-      DOCS_HINT = "See docs/upgrading.md for the migration path."
-      MUTEX = Mutex.new
-
-      CORE_SCHEMA_CHECKS = [
-        [
-          LlmCostTracker::Ledger::Schema::Calls,
-          "The llm_cost_tracker_calls table does not match the current LLM Cost Tracker schema."
-        ],
-        [
-          LlmCostTracker::Ledger::Schema::CallLineItems,
-          "The llm_cost_tracker_call_line_items table does not match the current LLM Cost Tracker schema."
-        ],
-        [
-          LlmCostTracker::Ledger::Schema::CallTags,
-          "The llm_cost_tracker_call_tags table does not match the current LLM Cost Tracker schema."
-        ]
-      ].freeze
-
-      OPTIONAL_CALL_ROLLUPS_CHECK = [
-        LlmCostTracker::Ledger::Schema::CallRollups,
-        "The llm_cost_tracker_call_rollups table does not match the current LLM Cost Tracker schema."
-      ].freeze
-
-      private_constant :MUTEX, :CORE_SCHEMA_CHECKS, :OPTIONAL_CALL_ROLLUPS_CHECK, :DOCS_HINT
 
       class << self
         def current
-          return @cached if defined?(@cached)
+          return @current if defined?(@current)
 
-          MUTEX.synchronize do
-            @cached = compute unless defined?(@cached)
-          end
-          @cached
+          @current = compute
         end
 
         def reset!
-          MUTEX.synchronize do
-            remove_instance_variable(:@cached) if defined?(@cached)
-          end
+          remove_instance_variable(:@current) if defined?(@current)
         end
 
         private
@@ -56,44 +22,16 @@ module LlmCostTracker
           LlmCostTracker::Logging.debug("Dashboard::SetupState recomputing")
           return calls_table_missing unless LlmCostTracker::Call.table_exists?
 
-          core_drift = drift_in(schema_checks_for_current_config)
-          return core_drift if core_drift
-          return nil unless LlmCostTracker.reconciliation_enabled?
-
-          reconciliation_drift
-        end
-
-        def schema_checks_for_current_config
-          return CORE_SCHEMA_CHECKS unless LlmCostTracker.configuration.cache_rollups
-
-          CORE_SCHEMA_CHECKS + [OPTIONAL_CALL_ROLLUPS_CHECK]
+          drift_in(LlmCostTracker::Ingestion.guards_for_current_config)
         end
 
         def drift_in(checks)
-          checks.each do |schema, message|
-            errors = schema.current_schema_errors
-            next if errors.empty?
-
-            return SetupRequired.new(message: message, details: errors + [DOCS_HINT])
-          end
-          nil
-        end
-
-        def reconciliation_drift
-          connection = ActiveRecord::Base.connection
-          LlmCostTracker::Reconciliation::SCHEMA_TABLES.each do |schema, table|
-            unless connection.data_source_exists?(table)
-              return SetupRequired.new(
-                message: "The #{table} table is required when reconciliation is enabled.",
-                details: ["run bin/rails generate llm_cost_tracker:reconciliation && bin/rails db:migrate", DOCS_HINT]
-              )
-            end
-
+          checks.each do |schema, table|
             errors = schema.current_schema_errors
             next if errors.empty?
 
             message = "The #{table} table does not match the current LLM Cost Tracker schema."
-            return SetupRequired.new(message: message, details: errors + [DOCS_HINT])
+            return SetupRequired.new(message: message, details: errors)
           end
           nil
         end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module Sort
+      DIRECTIONS = %w[asc desc].freeze
+    end
+  end
+end