llm_cost_tracker 0.9.0 → 0.10.0

data/lib/llm_cost_tracker/providers/openai/hosts.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module Hosts
+        API_HOSTS = %w[
+          api.openai.com
+          us.api.openai.com
+          eu.api.openai.com
+          au.api.openai.com
+          ca.api.openai.com
+          jp.api.openai.com
+          in.api.openai.com
+          sg.api.openai.com
+          kr.api.openai.com
+          gb.api.openai.com
+          ae.api.openai.com
+        ].freeze
+
+        DATA_RESIDENCY_HOST_PATTERN = /\A[a-z]{2,3}\.api\.openai\.com\z/
+
+        module_function
+
+        def api?(host)
+          API_HOSTS.include?(host.to_s.downcase)
+        end
+
+        def data_residency?(host)
+          host.to_s.downcase.match?(DATA_RESIDENCY_HOST_PATTERN)
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/openai/model_families.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module ModelFamilies
+        DATA_RESIDENCY_MODEL_PATTERN =
+          /\Agpt-5\.(?:4|5)(?:-(?:mini|nano|pro|codex(?:-mini|-max)?))?(?:-\d{4}-\d{2}-\d{2})?\z/
+
+        IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
+
+        CHARACTER_BILLED_TTS_MODEL_PATTERN = /\Atts-1(-hd)?\z/
+
+        REASONING_MODEL_PATTERNS = [
+          /\Agpt-5(\b|[\d.-])/i,
+          /\Ao\d+(\b|[\d.-])/i
+        ].freeze
+
+        NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
+
+        CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN = /-search-(?:preview|api)\b/i
+
+        module_function
+
+        def data_residency?(model)
+          model.to_s.match?(DATA_RESIDENCY_MODEL_PATTERN)
+        end
+
+        def image_output?(model)
+          model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
+        end
+
+        def character_billed_tts?(model)
+          model.to_s.match?(CHARACTER_BILLED_TTS_MODEL_PATTERN)
+        end
+
+        def chat_completions_search?(model)
+          model.to_s.match?(CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN)
+        end
+
+        def reasoning?(model)
+          name = model.to_s
+          return false if name.empty?
+          return false if NON_REASONING_GPT5_PATTERN.match?(name)
+
+          REASONING_MODEL_PATTERNS.any? { |pattern| pattern.match?(name) }
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/railtie.rb

@@ -12,11 +12,13 @@ module LlmCostTracker
       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/async_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"
+      require_relative "generators/llm_cost_tracker/upgrade_provider_invoice_imports_provider_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_provider_invoices_metadata_index_generator"
     end
 
     rake_tasks do

data/lib/llm_cost_tracker/reconciliation/diff.rb

@@ -28,7 +28,7 @@ module LlmCostTracker
         @provider = provider.to_s
         @period_start = parse_date(period_start)
         @period_end = parse_date(period_end)
-        @scope = symbolize(scope || {}).slice(*SCOPE_KEYS)
+        @scope = (scope || {}).to_h.transform_keys { |key| key.to_s.to_sym }.slice(*SCOPE_KEYS)
         @currency = (currency || Ledger::Rollups::DEFAULT_CURRENCY).to_s.upcase
         @drilldown_limit = drilldown_limit
         raise ArgumentError, "source must be present" if @source.empty?
@@ -37,7 +37,7 @@ module LlmCostTracker
       end
 
       def call
-        provider_total = scoped_invoices_relation_for(:cost, fully_contained: true)
+        provider_total = scoped_cost_invoices_in_window
                          .sum(:billed_amount)
                          .then { |sum| BigDecimal(sum.to_s) }
         local_index = local_attribution_index_distinct
@@ -66,7 +66,7 @@ module LlmCostTracker
           unmatched_local_calls: cap_by_amount(unmatched_locals, :total_cost),
           unmatched_local_calls_total: unmatched_local_calls_total_count(invoice_basis_values),
           non_cost_rows: cap_by_amount(non_cost_rows, :billed_amount),
-          non_cost_rows_total: non_cost_invoices_total_count
+          non_cost_rows_total: scoped_non_cost_invoices_relation.count
         )
       end
 
@@ -88,10 +88,10 @@ module LlmCostTracker
         relation.to_a
       end
 
-      def scoped_invoices_relation_for(row_type_filter = nil, fully_contained: false)
+      def scoped_cost_invoices_in_window
         relation = scoped_invoices_relation
-        relation = relation.where(period_start: period_start..).where(period_end: ..period_end) if fully_contained
-        return relation unless row_type_filter == :cost
+                   .where(period_start: period_start..)
+                   .where(period_end: ..period_end)
 
         connection = ProviderInvoice.connection
         if Ledger::Schema::Adapter.postgresql?(connection)
@@ -187,10 +187,8 @@ module LlmCostTracker
 
       def unmatched_provider_rows_from_sql(local_index)
         rows = BASIS_DIMENSION.each_key.flat_map do |basis|
-          next [] if basis == PERIOD_ONLY_BASIS
-
           column = BASIS_DIMENSION[basis].to_s
-          relation = scoped_invoices_relation_for(:cost, fully_contained: true)
+          relation = scoped_cost_invoices_in_window
           relation = where_match_basis_eq(relation, basis)
           relation = where_metadata_present(relation, column)
           values = local_index[basis].to_a
@@ -213,10 +211,8 @@ module LlmCostTracker
 
       def unmatched_provider_rows_total_count(local_index)
         BASIS_DIMENSION.each_key.sum do |basis|
-          next 0 if basis == PERIOD_ONLY_BASIS
-
           column = BASIS_DIMENSION[basis].to_s
-          relation = scoped_invoices_relation_for(:cost, fully_contained: true)
+          relation = scoped_cost_invoices_in_window
           relation = where_match_basis_eq(relation, basis)
           relation = where_metadata_present(relation, column)
           values = local_index[basis].to_a
@@ -227,13 +223,9 @@ module LlmCostTracker
 
       def local_attribution_index_distinct
         BASIS_DIMENSION.each_key.to_h do |basis|
-          if basis == PERIOD_ONLY_BASIS
-            [basis, Set.new]
-          else
-            column = BASIS_DIMENSION[basis]
-            values = scoped_calls_relation.where.not(column => nil).distinct.pluck(column)
-            [basis, Set.new(values)]
-          end
+          column = BASIS_DIMENSION[basis]
+          values = scoped_calls_relation.where.not(column => nil).distinct.pluck(column)
+          [basis, Set.new(values)]
         end
       end
 
@@ -252,38 +244,31 @@ module LlmCostTracker
 
       def unmatched_local_calls_total_count(invoice_basis_values)
         unmatched = 0
-        scoped_calls_relation.find_each(batch_size: 1_000) do |call|
-          attribution = ATTRIBUTION_KEYS.each_with_object({}) do |key, acc|
-            value = call.public_send(key)
-            acc[key] = value unless value.nil? || value.to_s.empty?
+        scoped_calls_relation.in_batches(of: 1_000) do |batch|
+          batch.pluck(*ATTRIBUTION_KEYS).each do |row|
+            attribution = ATTRIBUTION_KEYS.zip(row).each_with_object({}) do |(key, value), acc|
+              acc[key] = value unless value.nil? || value.to_s.empty?
+            end
+            next if attribution.empty?
+            next if local_call_matched?(attribution, invoice_basis_values)
+
+            unmatched += 1
           end
-          next if attribution.empty?
-          next if local_call_matched?(attribution, invoice_basis_values)
-
-          unmatched += 1
         end
         unmatched
       end
 
       def invoice_basis_values_distinct_sql
         BASIS_DIMENSION.each_key.to_h do |basis|
-          if basis == PERIOD_ONLY_BASIS
-            [basis, Set.new]
-          else
-            column = BASIS_DIMENSION[basis].to_s
-            relation = scoped_invoices_relation_for(:cost, fully_contained: true)
-            relation = where_match_basis_eq(relation, basis)
-            relation = where_metadata_present(relation, column)
-            values = pluck_metadata_distinct(relation, column)
-            [basis, Set.new(values)]
-          end
+          column = BASIS_DIMENSION[basis].to_s
+          relation = scoped_cost_invoices_in_window
+          relation = where_match_basis_eq(relation, basis)
+          relation = where_metadata_present(relation, column)
+          values = pluck_metadata_distinct(relation, column)
+          [basis, Set.new(values)]
         end
       end
 
-      def non_cost_invoices_total_count
-        scoped_non_cost_invoices_relation.count
-      end
-
       def scoped_non_cost_invoices_relation
         connection = ProviderInvoice.connection
         if Ledger::Schema::Adapter.postgresql?(connection)
@@ -414,10 +399,6 @@ module LlmCostTracker
         ((local - provider) * 100 / provider).round(4).to_f
       end
 
-      def symbolize(hash)
-        hash.to_h.transform_keys { |key| key.to_s.to_sym }
-      end
-
       def parse_date(value)
         return value if value.is_a?(Date)
 

data/lib/llm_cost_tracker/reconciliation/diff_result.rb

@@ -39,10 +39,6 @@ module LlmCostTracker
 
         delta_percent.abs <= threshold_percent
       end
-
-      def empty?
-        provider_total.zero? && local_total.zero?
-      end
     end
   end
 end

data/lib/llm_cost_tracker/reconciliation/importer.rb

@@ -81,6 +81,7 @@ module LlmCostTracker
 
         ProviderInvoiceImport.create!(
           source: source,
+          provider: provider,
           cursor: cursor,
           window_start: window&.first,
           window_end: window&.last,

data/lib/llm_cost_tracker/reconciliation/sources/anthropic_usage.rb

@@ -5,6 +5,7 @@ require "json"
 require "time"
 
 require_relative "fingerprint"
+require_relative "../../providers/anthropic/tier_classification"
 
 module LlmCostTracker
   module Reconciliation
@@ -18,8 +19,6 @@ module LlmCostTracker
         ROW_TYPE_COST = "cost"
         AUTHORITY_COST_API = "cost_api"
         DEFAULT_METER = "tokens"
-        DATA_RESIDENCY_GEOS = %w[us].freeze
-        private_constant :DATA_RESIDENCY_GEOS
 
         module_function
 
@@ -109,7 +108,9 @@ module LlmCostTracker
         def pricing_mode_for(result)
           modes = []
           modes << "batch" if result[:service_tier].to_s.downcase == "batch"
-          modes << "data_residency" if DATA_RESIDENCY_GEOS.include?(result[:inference_geo].to_s.downcase)
+          if LlmCostTracker::Providers::Anthropic::TierClassification.data_residency_geo?(result[:inference_geo])
+            modes << "data_residency"
+          end
           modes.empty? ? nil : modes.uniq.join("_")
         end
 

data/lib/llm_cost_tracker/report.rb

@@ -15,10 +15,6 @@ module LlmCostTracker
         )
 
         Formatter.new(report_data).to_s
-      rescue LoadError => e
-        "Unable to build LLM cost report: ActiveRecord storage is unavailable (#{e.message})"
-      rescue StandardError => e
-        "Unable to build LLM cost report: #{e.class}: #{e.message}"
       end
     end
   end

data/lib/llm_cost_tracker/retention.rb

@@ -32,6 +32,14 @@ module LlmCostTracker
           .delete_all
       end
 
+      def prune_inbox(older_than:, now: Time.now.utc)
+        cutoff = resolve_cutoff(older_than, now)
+        require_relative "ingestion"
+        return 0 unless LlmCostTracker::Ingestion::InboxEntry.table_exists?
+
+        LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff).delete_all
+      end
+
       private
 
       def resolve_cutoff(older_than, now)
@@ -61,20 +69,24 @@ module LlmCostTracker
 
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
-          rows = pluck_prunable(cutoff, batch_size)
+          cache_rollups = LlmCostTracker.configuration.cache_rollups
+          rows = pluck_prunable(cutoff, batch_size, with_rollup_columns: cache_rollups)
           next 0 if rows.empty?
 
-          deleted = LlmCostTracker::Call.where(id: rows.map(&:first)).delete_all
-          if deleted.positive? && LlmCostTracker.configuration.cache_rollups
-            LlmCostTracker::Ledger::Rollups.decrement!(rows)
-          end
+          ids = cache_rollups ? rows.map(&:first) : rows
+          deleted = LlmCostTracker::Call.where(id: ids).delete_all
+          LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
           deleted
         end
       end
 
-      def pluck_prunable(cutoff, batch_size)
-        LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-                            .pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
+      def pluck_prunable(cutoff, batch_size, with_rollup_columns:)
+        relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
+        if with_rollup_columns
+          relation.pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
+        else
+          relation.pluck(:id)
+        end
       end
     end
   end

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/inflections"
-require "json"
 
 module LlmCostTracker
   module Tags
@@ -24,7 +23,7 @@ module LlmCostTracker
       class << self
         def call(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
-          redacted = Array(config.redacted_tag_keys).map { |key| normalized_key(key) }
+          redacted = config.normalized_redacted_tag_keys
           limit = [config.max_tag_value_bytesize.to_i, 0].max
           max_count = [config.max_tag_count.to_i, 0].max
           tags.to_a.last(max_count).each_with_object({}) do |(key, value), sanitized|
@@ -32,6 +31,18 @@ module LlmCostTracker
           end
         end
 
+        def cap(tags, config: LlmCostTracker.configuration)
+          tags = (tags || {}).to_h
+          max_count = [config.max_tag_count.to_i, 0].max
+          return tags if tags.size <= max_count
+
+          tags.to_a.last(max_count).to_h
+        end
+
+        def normalized_key(key)
+          key.to_s.underscore.gsub(/[^a-z0-9]+/, "_").delete_prefix("_").delete_suffix("_")
+        end
+
         private
 
         def sanitized_value(key, value, redacted, limit)
@@ -92,27 +103,12 @@ module LlmCostTracker
           redacted.any? { |candidate| redacted_key_component?(normalized, candidate) }
         end
 
-        def normalized_key(key)
-          key.to_s.underscore.gsub(/[^a-z0-9]+/, "_").delete_prefix("_").delete_suffix("_")
-        end
-
         def redacted_key_component?(key, candidate)
           key == candidate ||
             key.start_with?("#{candidate}_") ||
             key.end_with?("_#{candidate}") ||
             key.include?("_#{candidate}_")
         end
-
-        def value_string(value)
-          case value
-          when Hash, Array
-            JSON.generate(value)
-          else
-            value.to_s
-          end
-        rescue JSON::GeneratorError, TypeError
-          value.to_s
-        end
       end
     end
   end

data/lib/llm_cost_tracker/token_usage.rb

@@ -21,6 +21,10 @@ module LlmCostTracker
     :total_tokens,
     :hidden_output_tokens
   ) do
+    def priced_quantities
+      Billing::Components::TOKEN_PRICED.to_h { |component| [component.key, public_send(component.token_key)] }
+    end
+
     def self.build_from_tokens(tokens)
       return tokens if tokens.is_a?(self)
       raise ArgumentError, "tokens must be a Hash, got #{tokens.class}" unless tokens.respond_to?(:to_h)

data/lib/llm_cost_tracker/tracker.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
-require "bigdecimal"
 require "securerandom"
 
 require_relative "ingestion"
@@ -15,28 +14,30 @@ module LlmCostTracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
     class << self
-      def enforce_budget!
+      def enforce_budget!(provider: nil, model: nil, request: nil)
         return unless LlmCostTracker.configuration.enabled
 
-        Budget.enforce!
+        Budget.enforce!(provider: provider, model: model, request: request)
       end
 
-      def record(capture:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil)
+      def record(event:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil)
         return unless LlmCostTracker.configuration.enabled
 
-        pricing_mode = Pricing.normalize_mode(pricing_mode) || capture.pricing_mode
+        pricing_mode = Pricing.normalize_mode(pricing_mode) || event.pricing_mode
         cost_data, pricing_snapshot, priced_line_items = Pricing.calculate(
-          provider: capture.provider,
-          model: capture.model,
-          tokens: capture.token_usage,
-          line_items: capture.line_items,
+          provider: event.provider,
+          model: event.model,
+          tokens: event.token_usage,
+          line_items: event.line_items,
           pricing_mode: pricing_mode
         )
 
-        Pricing::Unknown.handle!(capture.model) if cost_data.nil? && capture.token_usage.total_tokens.positive?
+        if cost_data.nil? && event.token_usage.total_tokens.positive? && priced_line_items.none?(&:priced?)
+          Pricing::Unknown.process(event.model)
+        end
 
         event = build_event(
-          capture: capture,
+          event: event,
           pricing_mode: pricing_mode,
           cost_data: cost_data,
           pricing_snapshot: pricing_snapshot,
@@ -46,21 +47,21 @@ module LlmCostTracker
           context_tags: context_tags
         )
 
-        save_event(event)
-        yield :after_save if block_given?
+        if Ingestion.async?
+          Ingestion::Inbox.save(event)
+          Ingestion::Worker.ensure_started
+        else
+          Ledger::Store.insert(event, skip_existence_check: true)
+        end
+
+        yield if block_given?
         notify_subscribers(event)
         Budget.check!(event)
 
         event
       end
 
-      def save_event(event)
-        if LlmCostTracker.configuration.durable_ingestion
-          Ingestion::Inbox.save(event)
-        else
-          Ingestion::Inline.save(event)
-        end
-      end
+      private
 
       def notify_subscribers(event)
         return unless ActiveSupport::Notifications.notifier.listening?(EVENT_NAME)
@@ -70,45 +71,25 @@ module LlmCostTracker
         Logging.warn("Subscriber raised on #{EVENT_NAME}: #{e.class}: #{e.message}")
       end
 
-      private
-
-      def token_pricing_partial?(token_usage:, cost_data:)
-        return false unless cost_data
-
-        Billing::Components::TOKEN_PRICED.any? do |component|
-          token_usage.public_send(component.token_key).positive? && cost_data[component.cost_key].nil?
-        end
-      end
-
-      def build_event(capture:, pricing_mode:, cost_data:, pricing_snapshot:, line_items:,
+      def build_event(event:, pricing_mode:, cost_data:, pricing_snapshot:, line_items:,
                       metadata:, latency_ms:, context_tags:)
         context_tags = (context_tags || LlmCostTracker::Tags::Context.tags).to_h
-        cost = cost_with_service_lines(cost_data, line_items)
+        cost = Pricing.combine_with_service_lines(cost_data, line_items)
         cost_status = Billing::CostStatus.call(
-          token_usage: capture.token_usage,
-          usage_source: capture.usage_source,
+          token_usage: event.token_usage,
+          usage_source: event.usage_source,
           token_cost: cost_data,
-          token_pricing_partial: token_pricing_partial?(token_usage: capture.token_usage, cost_data: cost_data),
+          token_pricing_partial: Pricing.token_pricing_partial?(event.token_usage, cost_data),
           service_line_items: line_items.reject(&:token?),
           total_cost: cost&.fetch(:total_cost, nil)
         )
 
-        Event.new(
+        event.with(
           event_id: SecureRandom.uuid,
-          provider: capture.provider,
-          model: capture.model,
-          token_usage: capture.token_usage,
           pricing_mode: pricing_mode,
           cost: cost,
-          tags: LlmCostTracker::Tags::Sanitizer.call(context_tags.merge(metadata.to_h)).freeze,
+          tags: build_tags(context_tags: context_tags, metadata: metadata),
           latency_ms: finite_latency_ms(latency_ms),
-          stream: capture.stream,
-          usage_source: capture.usage_source,
-          provider_response_id: capture.provider_response_id,
-          provider_project_id: capture.provider_project_id,
-          provider_api_key_id: capture.provider_api_key_id,
-          provider_workspace_id: capture.provider_workspace_id,
-          batch: capture.batch,
           tracked_at: Time.now.utc,
           cost_status: cost_status,
           pricing_snapshot: pricing_snapshot,
@@ -116,6 +97,11 @@ module LlmCostTracker
         )
       end
 
+      def build_tags(context_tags:, metadata:)
+        sanitized_metadata = LlmCostTracker::Tags::Sanitizer.call(metadata.to_h)
+        LlmCostTracker::Tags::Sanitizer.cap(context_tags.merge(sanitized_metadata)).freeze
+      end
+
       def finite_latency_ms(latency_ms)
         return nil if latency_ms.nil?
 
@@ -123,33 +109,6 @@ module LlmCostTracker
       rescue ArgumentError, TypeError, FloatDomainError
         nil
       end
-
-      def cost_with_service_lines(cost_data, line_items)
-        priced_services = line_items.reject(&:token?).select(&:priced?)
-        return cost_data if priced_services.empty?
-
-        base_currency = (cost_data && cost_data[:currency]) || Billing::LineItem::USD
-        matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
-        warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
-
-        cost = cost_data ? cost_data.dup : {}
-        cost[:currency] ||= base_currency.to_s
-        return cost if matching.empty?
-
-        service_total = matching.sum(BigDecimal("0"), &:cost_value)
-        base_total = BigDecimal(cost.fetch(:total_cost, 0).to_s)
-        cost[:total_cost] = (base_total + service_total).round(8)
-        cost
-      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

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end