llm_cost_tracker 0.14.2 → 0.15.0

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -4,13 +4,13 @@ require_relative "../pricing"
 require_relative "../charges/line_item"
 require_relative "../ledger/rollups"
 require_relative "../usage/token_usage"
-require_relative "../budget/per_tag"
+require_relative "../budget"
 
 module LlmCostTracker
   module Pricing
     module Backfill
       Result = Data.define(:examined, :recomputed, :still_unknown)
-      RollupEvent = Data.define(:provider, :tracked_at, :pricing_snapshot, :total_cost)
+      RollupEvent = Data.define(:provider, :tracked_at, :pricing_snapshot, :total_cost, :tags)
 
       DEFAULT_BATCH_SIZE = 500
       REGISTRY_SOURCES = %w[pricing_overrides prices_file bundled].freeze
@@ -21,23 +21,12 @@ module LlmCostTracker
         def call(scope: default_scope, batch_size: DEFAULT_BATCH_SIZE, reprice: false)
           examined = 0
           recomputed = 0
-
-          scope.includes(:line_items).find_in_batches(batch_size: batch_size) do |batch|
-            rollup_events = []
-            LlmCostTracker::Call.transaction do
-              batch.each do |call|
-                examined += 1
-                calculation = recompute_for(call, reprice: reprice)
-                next unless calculation
-
-                rollup_events << rollup_event_for(call, calculation)
-                persist!(call, calculation)
-                recomputed += 1
-              end
-              Ledger::Rollups.increment!(rollup_events)
-            end
+          scope.includes(:line_items, :tag_records).find_in_batches(batch_size: batch_size) do |batch|
+            batch_examined, rollup_events = recompute_batch(batch, reprice: reprice)
+            examined += batch_examined
+            recomputed += rollup_events.size
+            LlmCostTracker::Budget.notify_repriced_safely!(rollup_events)
           end
-
           Result.new(examined: examined, recomputed: recomputed, still_unknown: examined - recomputed)
         end
 
@@ -55,8 +44,32 @@ module LlmCostTracker
           calls.where(usage_source: nil).or(calls.where.not(usage_source: Usage::Source::UNKNOWN))
         end
 
+        def recompute_batch(batch, reprice:)
+          examined = 0
+          rollup_events = []
+          LlmCostTracker::Call.transaction do
+            batch.each do |call|
+              calculation = recompute_for(call, reprice: reprice)
+              next if calculation && changed_since_read?(call)
+
+              examined += 1
+              next unless calculation
+
+              rollup_events << rollup_event_for(call, calculation)
+              persist!(call, calculation)
+            end
+            Ledger::Rollups.increment!(rollup_events)
+          end
+          [examined, rollup_events]
+        end
+
         def recompute_for(call, reprice:)
-          calculation = Pricing::Calculation.for(
+          calculation = calculation_for(call, reprice: reprice)
+          calculation if applicable?(call, calculation, reprice: reprice)
+        end
+
+        def calculation_for(call, reprice:)
+          Pricing::Calculation.for(
             provider: call.provider,
             model: call.model,
             tokens: token_usage_from(call),
@@ -65,13 +78,24 @@ module LlmCostTracker
             usage_source: call.usage_source,
             at: call.tracked_at
           )
-          return unless calculation.token_cost || provider_billed?(calculation)
-          return if [calculation.cost.total, calculation.cost_status] == [call.total_cost, call.cost_status]
-          return calculation if reprice
+        end
 
+        def applicable?(call, calculation, reprice:)
+          return false unless calculation.token_cost || provider_billed?(calculation)
+          return false if [calculation.cost.total, calculation.cost_status] == [call.total_cost, call.cost_status]
+
+          reprice || recorded_rates_current?(call, calculation)
+        end
+
+        def recorded_rates_current?(call, calculation)
           rates = calculation.priced_line_items.to_h { |item| [dimension_key(item), item.rate_amount] }
           recorded = call.line_items.select { |record| record.unit == "token" && record.rate_amount }
-          calculation if recorded.all? { |record| record.rate_amount == rates[dimension_key(record)] }
+          recorded.all? { |record| record.rate_amount == rates[dimension_key(record)] }
+        end
+
+        def changed_since_read?(call)
+          stored = LlmCostTracker::Call.lock.where(id: call.id).pick(:total_cost, :cost_status)
+          stored != [call.total_cost, call.cost_status]
         end
 
         def provider_billed?(calculation)
@@ -88,14 +112,18 @@ module LlmCostTracker
           call.update!(
             total_cost: calculation.cost.total,
             pricing_snapshot: calculation.snapshot,
-            cost_status: calculation.cost_status
+            cost_status: calculation.cost_status,
+            pricing_mode: calculation.mode
           )
           resync_tag_costs(call, calculation.cost.total)
-          token_priced = calculation.priced_line_items.select(&:token?).index_by { |item| dimension_key(item) }
-          service_priced = calculation.priced_line_items.reject(&:token?)
-          token_records, service_records = call.line_items.partition { |record| record.unit == "token" }
+          apply_rates(call.line_items, calculation.priced_line_items)
+        end
 
-          token_records.each { |record| apply_rate(record, token_priced[dimension_key(record)]) }
+        def apply_rates(records, priced_items)
+          token_records, service_records = records.partition { |record| record.unit == "token" }
+          token_priced, service_priced = priced_items.partition(&:token?)
+          by_dimension = token_priced.index_by { |item| dimension_key(item) }
+          token_records.each { |record| apply_rate(record, by_dimension[dimension_key(record)]) }
           service_records.sort_by(&:position).zip(service_priced).each { |record, priced| apply_rate(record, priced) }
         end
 
@@ -111,6 +139,7 @@ module LlmCostTracker
           return unless priced
 
           record.update!(
+            quantity: priced.quantity,
             rate_amount: priced.rate_amount,
             rate_quantity: priced.rate_quantity,
             cost: priced.cost,
@@ -131,7 +160,8 @@ module LlmCostTracker
             provider: call.provider,
             tracked_at: call.tracked_at,
             pricing_snapshot: calculation.snapshot,
-            total_cost: calculation.cost.total - call.total_cost.to_d
+            total_cost: calculation.cost.total - call.total_cost.to_d,
+            tags: call.tag_pairs
           )
         end
 

data/lib/llm_cost_tracker/pricing/calculation/iterations.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Pricing
+    class Calculation
+      class Iterations
+        def initialize(provider:, requested_mode:, at:)
+          @provider = provider
+          @requested_mode = requested_mode
+          @at = at
+          @partial = false
+        end
+
+        def price(line_item)
+          calculation = calculation_for(line_item.details.to_h.transform_keys(&:to_sym))
+          cost = calculation.token_cost
+          return line_item unless cost
+
+          @partial ||= calculation.cost_status == Charges::CostStatus::PARTIAL
+          status = cost.total.zero? ? Charges::CostStatus::FREE : Charges::CostStatus::COMPLETE
+          line_item.with(rate_amount: cost.total, cost: cost.total, currency: cost.currency, cost_status: status)
+        end
+
+        def partial?
+          @partial
+        end
+
+        private
+
+        def calculation_for(details)
+          model = details[:model].to_s
+          Calculation.for(
+            provider: @provider,
+            model: model,
+            tokens: details.slice(*Usage::TokenUsage.members),
+            pricing_mode: mode_for(model),
+            at: @at
+          )
+        end
+
+        def mode_for(model)
+          return @requested_mode if Matcher.modifier_priced?(provider: @provider, model: model, modifier: "fast")
+
+          Mode.compose(Mode.tokenize(@requested_mode) - ["fast"])
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/calculation/quantities.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Pricing
+    class Calculation
+      class Quantities
+        UNIT_BILLED_KINDS = %w[transcription_minute text_to_speech_character ocr_page rerank_search_unit].freeze
+
+        def initialize(token_usage, line_items, prices)
+          @token_usage = token_usage
+          @line_items = line_items
+          @price_keys = prices.keys
+        end
+
+        def to_h
+          @line_items.each_with_object(token_counts) do |line_item, quantities|
+            dimension = line_item.dimension
+            next unless dimension&.parent
+
+            quantity = [line_item.quantity.to_i, quantities.fetch(dimension.parent)].min
+            quantities[dimension.parent] -= quantity
+            quantities[dimension.key] = quantities.fetch(dimension.key, 0) + quantity
+          end
+        end
+
+        private
+
+        def token_counts
+          counts = @token_usage.priced_quantities
+          billed_by_unit? ? counts.transform_values { 0 } : counts
+        end
+
+        def billed_by_unit?
+          !@price_keys.intersect?(Registry::PRICE_KEYS) &&
+            (@price_keys & UNIT_BILLED_KINDS).intersect?(@line_items.map(&:kind))
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/calculation/snapshot.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+
+module LlmCostTracker
+  module Pricing
+    class Calculation
+      module Snapshot
+        SCHEMA_VERSION = 1
+
+        class << self
+          def for_match(match, service_lines, token_lines)
+            {
+              "schema_version" => SCHEMA_VERSION,
+              "source" => match.source.name,
+              "source_key" => match.key,
+              "source_version" => match.source.version,
+              "matched_by" => match.matched_by.to_s,
+              "currency" => match.source.currency,
+              "rates" => rates(service_lines).merge(rates(token_lines))
+            }
+          end
+
+          def for_service_charges(lines, currency)
+            {
+              "schema_version" => SCHEMA_VERSION,
+              "source" => lines.first.price_source,
+              "source_version" => lines.first.price_source_version,
+              "matched_by" => "service_charges",
+              "currency" => currency,
+              "rates" => rates(lines)
+            }
+          end
+
+          private
+
+          def rates(line_items)
+            line_items.each_with_object({}) do |line_item, rates|
+              next if line_item.price_key.nil? || line_item.rate_amount.nil?
+
+              rates[line_item.price_key] ||= {
+                "amount" => line_item.rate_amount.to_d.to_s("F"),
+                "quantity" => Integer(line_item.rate_quantity)
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/calculation/totals.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module LlmCostTracker
+  module Pricing
+    class Calculation
+      module Totals
+        class << self
+          def token_cost(token_lines, currency)
+            Charges::Cost.new(components: components(token_lines).freeze, total: sum(token_lines), currency: currency)
+          end
+
+          def in_call_currency(service_lines, token_cost)
+            return service_lines if service_lines.empty?
+
+            currency = token_cost&.currency || service_lines.first.currency || LlmCostTracker::DEFAULT_CURRENCY
+            counted, dropped = service_lines.partition { |line| line.currency.to_s == currency.to_s }
+            warn_currency_mismatch(dropped, currency) if dropped.any?
+            counted
+          end
+
+          def with_service_lines(token_cost, service_lines)
+            return token_cost if service_lines.empty?
+
+            Charges::Cost.new(
+              components: token_cost ? token_cost.components : {}.freeze,
+              total: (token_cost&.total || BigDecimal("0")) + sum(service_lines),
+              currency: (token_cost&.currency || service_lines.first.currency).to_s
+            )
+          end
+
+          private
+
+          def components(token_lines)
+            by_component = token_lines.group_by { |line| line.dimension.parent || line.dimension.key }
+            Usage::Catalog.token_priced.each_with_object({}) do |dimension, components|
+              lines = by_component.fetch(dimension.key, [])
+              components[dimension.cost_key] = sum(lines) unless lines.any?(&:unpriced?)
+            end
+          end
+
+          def sum(lines)
+            lines.sum(BigDecimal("0")) { |line| line.cost_value.round(8) }
+          end
+
+          def warn_currency_mismatch(lines, base_currency)
+            currencies = lines.map { |line| line.currency.to_s }.uniq.sort
+            Logging.warn(
+              "Service line currency mismatch: header is #{base_currency}, dropping " \
+              "#{lines.size} priced line(s) in #{currencies.join(', ')} from header total. " \
+              "Per-line costs are still recorded; header total reflects #{base_currency} only."
+            )
+          end
+        end
+      end
+    end
+  end
+end