llm_cost_tracker 0.8.0 → 0.9.0

data/lib/llm_cost_tracker/pricing.rb

@@ -6,6 +6,7 @@ require "time"
 require_relative "version"
 require_relative "token_usage"
 require_relative "billing/components"
+require_relative "pricing/mode"
 require_relative "pricing/registry"
 require_relative "pricing/lookup"
 require_relative "pricing/effective_prices"
@@ -13,7 +14,7 @@ require_relative "pricing/explainer"
 require_relative "pricing/service_charges"
 
 module LlmCostTracker
-  module Pricing
+  module Pricing # rubocop:disable Metrics/ModuleLength
     extend ServiceCharges
 
     STANDARD_MODE_VALUES = %i[auto default standard standard_only].freeze
@@ -24,7 +25,7 @@ module LlmCostTracker
       def normalize_mode(value)
         return nil if value.nil?
 
-        mode = value.is_a?(Symbol) ? value.downcase : normalize_string_mode(value)
+        mode = normalize_string_mode(value.to_s)
         return nil unless mode
 
         STANDARD_MODE_VALUES.include?(mode) ? nil : mode
@@ -42,29 +43,26 @@ module LlmCostTracker
         cost_from(calculation)
       end
 
-      def cost_and_snapshot_for(provider:, model:, tokens:, pricing_mode: nil)
+      def calculate(provider:, model:, tokens:, line_items:, pricing_mode: nil)
         calculation = calculation_for(
           provider: provider,
           model: model,
           tokens: tokens,
           pricing_mode: pricing_mode
         )
-        return [nil, nil] unless calculation
-
-        [cost_from(calculation), snapshot_from(calculation)]
+        cost_data = calculation && cost_from(calculation)
+        snapshot = calculation && snapshot_from(calculation)
+        priced = apply_calculation_to_line_items(line_items, calculation,
+                                                 provider: provider, pricing_mode: pricing_mode)
+        [cost_data, snapshot, priced]
       end
 
       def price_line_items(provider:, model:, line_items:, pricing_mode: nil)
         token_usage = TokenUsage.build_from_tokens(token_attributes_from(line_items))
         calculation = calculation_for(provider: provider, model: model, tokens: token_usage, pricing_mode: pricing_mode)
         snapshot = calculation && snapshot_from(calculation)
-
-        priced = line_items.map do |line_item|
-          next price_token_line_item(line_item, calculation) if line_item.unit == :token
-
-          price_service_charge_line_item(line_item, provider: provider, pricing_mode: pricing_mode)
-        end
-
+        priced = apply_calculation_to_line_items(line_items, calculation,
+                                                 provider: provider, pricing_mode: pricing_mode)
         [priced, snapshot]
       end
 
@@ -91,7 +89,7 @@ module LlmCostTracker
 
       def stored_cost_attributes(attributes)
         value = attributes.to_h[:total_cost]
-        value.nil? ? {} : { total_cost: value }
+        value ? { total_cost: value } : {}
       end
 
       private
@@ -109,7 +107,7 @@ module LlmCostTracker
           cost = costs[component.key]
           result[component.cost_key] = cost.round(8) unless cost.nil?
         end
-        values[:total_cost] = costs.values.compact.sum.round(8)
+        values[:total_cost] = costs.values.compact.sum(BigDecimal("0")).round(8)
         values
       end
 
@@ -163,6 +161,17 @@ module LlmCostTracker
         end
       end
 
+      def apply_calculation_to_line_items(line_items, calculation, provider:, pricing_mode:)
+        line_items.map do |line_item|
+          next price_token_line_item(line_item, calculation) if line_item.unit == :token
+
+          price_service_charge_line_item(line_item,
+                                         provider: provider,
+                                         calculation: calculation,
+                                         pricing_mode: pricing_mode)
+        end
+      end
+
       def token_attributes_from(line_items)
         line_items.each_with_object({}) do |line_item, totals|
           next unless line_item.unit == :token
@@ -195,16 +204,35 @@ module LlmCostTracker
         )
       end
 
-      def price_service_charge_line_item(line_item, provider:, pricing_mode:)
+      def price_service_charge_line_item(line_item, provider:, calculation:, pricing_mode:)
         return line_item if line_item.priced?
         return line_item unless line_item.billable?
 
-        rate = charge_rate(provider: provider, component: line_item.kind, pricing_mode: pricing_mode)
+        rate = model_rate_for(line_item, calculation) ||
+               charge_rate(provider: provider, component: line_item.kind, pricing_mode: pricing_mode)
         return line_item unless rate
 
         line_item.apply_rate(rate)
       end
 
+      def model_rate_for(line_item, calculation)
+        return nil unless calculation
+
+        match = calculation[:match]
+        amount = match.prices[line_item.kind] || match.prices[line_item.kind.to_s]
+        return nil unless amount.is_a?(Numeric)
+
+        component = Billing::Components::BY_KEY[line_item.kind]
+        {
+          amount: BigDecimal(amount.to_s),
+          quantity: BigDecimal(Billing::RATE_BASIS_QUANTITIES.fetch(component.rate_basis).to_s),
+          currency: "USD",
+          source: match.source,
+          source_key: "#{match.key}.#{line_item.kind}",
+          source_version: source_version_for(match.source)
+        }
+      end
+
       def component_for_line_item(line_item)
         Billing::Components::REGISTRY.find do |component|
           component.kind == line_item.kind &&
@@ -230,10 +258,10 @@ module LlmCostTracker
       end
 
       def token_cost(tokens, per_million_price)
-        return 0.0 if tokens.zero?
+        return BigDecimal("0") if tokens.zero?
         return nil if per_million_price.nil?
 
-        (tokens * per_million_price) / RATE_DENOMINATOR_TOKENS
+        (BigDecimal(tokens.to_s) * BigDecimal(per_million_price.to_s)) / RATE_DENOMINATOR_TOKENS
       end
     end
   end

data/lib/llm_cost_tracker/railtie.rb

@@ -11,6 +11,12 @@ module LlmCostTracker
     generators do
       require_relative "generators/llm_cost_tracker/install_generator"
       require_relative "generators/llm_cost_tracker/prices_generator"
+      require_relative "generators/llm_cost_tracker/call_rollups_generator"
+      require_relative "generators/llm_cost_tracker/durable_ingestion_generator"
+      require_relative "generators/llm_cost_tracker/reconciliation_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_call_rollups_provider_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_image_tokens_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_call_tags_key_value_index_generator"
     end
 
     rake_tasks do

data/lib/llm_cost_tracker/reconcile_tasks.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "reconciliation"
+
+module LlmCostTracker
+  module ReconcileTasks
+    SOURCE_PARSERS = {
+      "openai" => Reconciliation::Sources::OpenaiUsage,
+      "anthropic" => Reconciliation::Sources::AnthropicUsage
+    }.freeze
+    GENERIC_SOURCES = %w[csv].freeze
+
+    module_function
+
+    def run_import(env: ENV, output: $stdout, error_output: $stderr)
+      result = import_from_env(env: env)
+      output.puts "llm_cost_tracker: imported #{result.total_imported} rows " \
+                  "(inserted=#{result.inserted}, updated=#{result.updated}, skipped=#{result.skipped})"
+      result.errors.each { |error| error_output.puts "  error: #{error}" }
+      raise "llm_cost_tracker: reconcile import had errors" unless result.success?
+
+      result
+    end
+
+    def run_diff(env: ENV, output: $stdout)
+      diff = diff_from_env(env: env)
+      print_diff(diff, output: output)
+      diff
+    end
+
+    def import_from_env(env: ENV)
+      source = required_env(env, "SOURCE")
+      input_path = required_env(env, "INPUT")
+      raise ArgumentError, "INPUT file not found: #{input_path}" unless File.exist?(input_path)
+
+      payload = JSON.parse(File.read(input_path))
+      rows = parse_rows(source: source, payload: payload)
+      Reconciliation.import(source: source.to_sym, rows: rows, provider: env["PROVIDER"])
+    end
+
+    def diff_from_env(env: ENV)
+      source = required_env(env, "SOURCE")
+      period_start = Date.parse(required_env(env, "PERIOD_START"))
+      period_end = Date.parse(required_env(env, "PERIOD_END"))
+      Reconciliation.diff(source: source.to_sym, period_start: period_start, period_end: period_end,
+                          provider: env["PROVIDER"],
+                          drilldown_limit: parse_drilldown_limit(env["DRILLDOWN_LIMIT"]))
+    end
+
+    def parse_drilldown_limit(value)
+      return Reconciliation::Diff::DEFAULT_DRILLDOWN_LIMIT if value.nil? || value.to_s.empty?
+      return nil if value.to_s.downcase == "all"
+
+      Integer(value)
+    end
+
+    def print_diff(diff, output: $stdout)
+      output.puts "llm_cost_tracker: reconciliation diff for #{diff.source} " \
+                  "#{diff.period_start}..#{diff.period_end}"
+      output.puts "  provider_total: #{diff.provider_total.to_s('F')} #{diff.currency}"
+      output.puts "  local_total:    #{diff.local_total.to_s('F')} #{diff.currency} " \
+                  "(from #{diff.local_total_source})"
+      output.puts "  delta:          #{diff.delta_amount.to_s('F')} (#{diff.delta_percent || 'n/a'}%)"
+      print_unmatched_provider_rows(diff, output)
+      print_unmatched_local_calls(diff, output)
+      print_non_cost_rows(diff, output)
+    end
+
+    def parse_rows(source:, payload:)
+      parser = SOURCE_PARSERS[source.to_s]
+      return parser.parse(payload) if parser
+      return Array(payload["rows"]) if GENERIC_SOURCES.include?(source.to_s)
+
+      known = (SOURCE_PARSERS.keys + GENERIC_SOURCES).join(", ")
+      raise ArgumentError, "unknown SOURCE #{source.inspect}; known sources: #{known}"
+    end
+
+    def required_env(env, key)
+      value = env[key].to_s.strip
+      raise ArgumentError, "missing #{key}" if value.empty?
+
+      value
+    end
+
+    def print_unmatched_provider_rows(diff, output)
+      return if diff.unmatched_provider_rows.empty?
+
+      output.puts "  unmatched provider rows#{truncation_suffix(diff.unmatched_provider_rows.size,
+                                                                diff.unmatched_provider_rows_total)}:"
+      diff.unmatched_provider_rows.each do |row|
+        output.puts "    #{row[:external_id]} (#{row[:match_basis]}): " \
+                    "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
+      end
+    end
+
+    def print_unmatched_local_calls(diff, output)
+      return if diff.unmatched_local_calls.empty?
+
+      output.puts "  unmatched local calls#{truncation_suffix(diff.unmatched_local_calls.size,
+                                                              diff.unmatched_local_calls_total)}:"
+      diff.unmatched_local_calls.each do |row|
+        output.puts "    #{row[:count]} calls / #{row[:total_cost].to_s('F')} " \
+                    "#{format_attribution(row[:attribution])}"
+      end
+    end
+
+    def print_non_cost_rows(diff, output)
+      return if diff.non_cost_rows.empty?
+
+      output.puts "  non-cost evidence#{truncation_suffix(diff.non_cost_rows.size,
+                                                          diff.non_cost_rows_total)}:"
+      diff.non_cost_rows.each do |row|
+        output.puts "    [#{row[:row_type]}/#{row[:meter]}] #{format_amount(row[:billed_amount])} " \
+                    "#{format_attribution(row[:attribution])}"
+      end
+    end
+
+    def truncation_suffix(shown, total)
+      return "" if shown >= total
+
+      " (showing #{shown} of #{total} — pass DRILLDOWN_LIMIT=all to see every row)"
+    end
+
+    def format_amount(value)
+      value.nil? ? "n/a" : value.to_s("F")
+    end
+
+    def format_attribution(attribution)
+      LlmCostTracker::Masking.format_attribution(attribution, separator: ",")
+    end
+  end
+end