llm_cost_tracker 0.12.0 → 0.14.0

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -4,6 +4,7 @@ require_relative "../pricing"
 require_relative "../charges/line_item"
 require_relative "../ledger/rollups"
 require_relative "../usage/token_usage"
+require_relative "../budget/per_tag"
 
 module LlmCostTracker
   module Pricing
@@ -30,7 +31,7 @@ module LlmCostTracker
                 rollup_events << rollup_event_for(call, calculation)
                 recomputed += 1
               end
-              Ledger::Rollups.increment!(rollup_events) if rollup_events.any?
+              Ledger::Rollups.increment!(rollup_events)
             end
           end
 
@@ -61,6 +62,7 @@ module LlmCostTracker
             pricing_snapshot: calculation.snapshot,
             cost_status: calculation.cost_status
           )
+          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" }
@@ -69,6 +71,14 @@ module LlmCostTracker
           service_records.sort_by(&:position).zip(service_priced).each { |record, priced| apply_rate(record, priced) }
         end
 
+        def resync_tag_costs(call, total_cost)
+          return unless LlmCostTracker::Budget::PerTag.columns?
+
+          LlmCostTracker::CallTag
+            .where(llm_cost_tracker_call_id: call.id)
+            .update_all(total_cost: total_cost)
+        end
+
         def apply_rate(record, priced)
           return unless priced
 

data/lib/llm_cost_tracker/pricing/calculation.rb

@@ -10,7 +10,8 @@ module LlmCostTracker
   module Pricing
     class Calculation
       RATE_DENOMINATOR_TOKENS = Pricing::RATE_BASIS_QUANTITIES.fetch("per_million_tokens")
-      private_constant :RATE_DENOMINATOR_TOKENS
+      SNAPSHOT_SCHEMA_VERSION = 1
+      private_constant :RATE_DENOMINATOR_TOKENS, :SNAPSHOT_SCHEMA_VERSION
 
       def self.for(provider:, model:, tokens:, pricing_mode:, line_items: [], usage_source: nil)
         new(provider: provider,
@@ -61,7 +62,12 @@ module LlmCostTracker
       def snapshot
         return @snapshot if defined?(@snapshot)
 
-        @snapshot = priceable? ? build_snapshot : nil
+        @snapshot =
+          if priceable?
+            build_snapshot
+          elsif kept_service_lines.any?
+            build_service_snapshot
+          end
       end
 
       def cost
@@ -131,7 +137,7 @@ module LlmCostTracker
 
       def build_snapshot
         {
-          "schema_version" => 1,
+          "schema_version" => SNAPSHOT_SCHEMA_VERSION,
           "source" => match.source.name,
           "source_key" => match.key,
           "source_version" => match.source.version,
@@ -141,6 +147,18 @@ module LlmCostTracker
         }
       end
 
+      def build_service_snapshot
+        primary = kept_service_lines.first
+        {
+          "schema_version" => SNAPSHOT_SCHEMA_VERSION,
+          "source" => primary.price_source,
+          "source_version" => primary.price_source_version,
+          "matched_by" => "service_charges",
+          "currency" => cost.currency,
+          "rates" => service_charge_rates
+        }
+      end
+
       def token_charge_rates
         priced_token_line_items.each_with_object({}) do |line_item, rates|
           next if line_item.price_key.nil? || line_item.rate_amount.nil?
@@ -150,8 +168,8 @@ module LlmCostTracker
       end
 
       def service_charge_rates
-        priced_line_items.each_with_object({}) do |line_item, rates|
-          next if line_item.token? || line_item.price_key.nil? || line_item.rate_amount.nil?
+        kept_service_lines.each_with_object({}) do |line_item, rates|
+          next if line_item.price_key.nil? || line_item.rate_amount.nil?
 
           rates[line_item.price_key] ||= rate_entry(line_item.rate_amount, line_item.rate_quantity)
         end
@@ -162,23 +180,23 @@ module LlmCostTracker
       end
 
       def price_token(line_item)
-        dimension = dimension_for(line_item)
+        dimension = line_item.dimension
         return line_item unless dimension
         return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) unless priceable?
 
         price = effective[dimension.key]
         return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) if price.nil?
 
-        line_item.with_rate(token_rate(dimension, price))
+        line_item.with_rate(token_rate(price))
       end
 
-      def token_rate(dimension, price)
+      def token_rate(price)
         Pricing::Rate.new(
-          amount: price.to_d,
+          amount: price.amount.to_d,
           quantity: RATE_DENOMINATOR_TOKENS.to_d,
           currency: match.source.currency,
           source: match.source.name,
-          source_key: dimension.key,
+          source_key: price.key,
           source_version: match.source.version
         )
       end
@@ -210,30 +228,31 @@ module LlmCostTracker
         )
       end
 
-      def dimension_for(line_item)
-        Usage::Catalog.all.find do |dimension|
-          dimension.kind == line_item.kind &&
-            dimension.direction == line_item.direction &&
-            dimension.modality == line_item.modality &&
-            dimension.cache_state == line_item.cache_state &&
-            dimension.unit == line_item.unit
+      def kept_service_lines
+        return @kept_service_lines if defined?(@kept_service_lines)
+
+        @kept_service_lines = begin
+          priced_services = priced_line_items.reject(&:token?).select(&:priced?)
+          if priced_services.empty?
+            []
+          else
+            base_currency = base_currency_for(token_cost, priced_services)
+            matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
+            warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
+            matching
+          end
         end
       end
 
       def combine_service_lines
         cost = token_cost
-        priced_services = priced_line_items.reject(&:token?).select(&:priced?)
-        return cost if priced_services.empty?
-
-        base_currency = base_currency_for(cost, priced_services)
-        matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
-        warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
+        return cost if kept_service_lines.empty?
 
-        service_total = matching.sum(BigDecimal("0")) { |line| line.cost_value.round(8) }
+        service_total = kept_service_lines.sum(BigDecimal("0")) { |line| line.cost_value.round(8) }
         Charges::Cost.new(
           components: cost ? cost.components : {}.freeze,
           total: (cost&.total || BigDecimal("0")) + service_total,
-          currency: (cost&.currency || base_currency).to_s
+          currency: (cost&.currency || kept_service_lines.first.currency).to_s
         )
       end
 

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -8,38 +8,49 @@ require_relative "price_key"
 module LlmCostTracker
   module Pricing
     module EffectivePrices
+      Resolved = Data.define(:amount, :key)
+
       class << self
         def call(usage:, quantities:, prices:, pricing_mode:)
           context_tier = context_tier?(usage: usage, prices: prices)
           orderings = pricing_mode && Mode.permutations_for(pricing_mode)
 
           quantities.to_h do |price_key, tokens|
-            price = if tokens.positive?
-                      price_for(
-                        prices: prices,
-                        key: price_key,
-                        orderings: orderings,
-                        context_tier: context_tier
-                      )
-                    else
-                      BigDecimal("0")
-                    end
-            [price_key, price]
+            resolved = if tokens.positive?
+                         price_for(
+                           prices: prices,
+                           key: price_key,
+                           orderings: orderings,
+                           context_tier: context_tier
+                         )
+                       else
+                         Resolved.new(amount: BigDecimal("0"), key: price_key)
+                       end
+            [price_key, resolved]
           end
         end
 
         private
 
         def price_for(prices:, key:, orderings:, context_tier:)
-          return prices[PriceKey.build(key, above_context: context_tier)] unless orderings
+          unless orderings
+            standard = PriceKey.build(key, above_context: context_tier)
+            return resolve(prices[standard], standard)
+          end
 
           orderings.each do |mode|
-            direct = prices[PriceKey.build(key, mode: mode, above_context: context_tier)]
-            return direct if direct
+            table_key = PriceKey.build(key, mode: mode, above_context: context_tier)
+            direct = prices[table_key]
+            return resolve(direct, table_key) if direct
           end
           return nil if %w[input output].include?(key)
 
-          derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          derived = derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          resolve(derived, nil)
+        end
+
+        def resolve(amount, key)
+          amount && Resolved.new(amount: amount, key: key)
         end
 
         def derived_mode_price(prices:, key:, modes:, context_tier:)

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -9,22 +9,43 @@ module LlmCostTracker
     module Matcher
       Match = Data.define(:source, :key, :prices, :matched_by)
 
+      CACHE_LIMIT = 2048
+      private_constant :CACHE_LIMIT
+
       class << self
         def lookup(provider:, model:)
           provider_name = provider.to_s.presence
           model_name = model.to_s
           return nil if model_name.empty?
 
-          lookup_match(provider_name: provider_name, model_name: model_name)
+          sources = Registry.sources
+          reset_cache(sources) unless @cache_sources.equal?(sources)
+          key = [provider_name, model_name].freeze
+          return @cache[key] if @cache.key?(key)
+
+          @cache.clear if @cache.size >= CACHE_LIMIT
+          @cache[key] = lookup_match(sources, provider_name, model_name)
+        end
+
+        def modifier_priced?(provider:, model:, modifier:)
+          prices = lookup(provider: provider, model: model)&.prices
+          return false unless prices
+
+          prices.any? { |key, _| key.to_s.include?(modifier) }
         end
 
         private
 
-        def lookup_match(provider_name:, model_name:)
+        def reset_cache(sources)
+          @cache_sources = sources
+          @cache = {}
+        end
+
+        def lookup_match(sources, provider_name, model_name)
           provider_model = provider_name ? "#{provider_name}/#{model_name}" : model_name
           normalized = normalize_model_name(model_name)
 
-          Registry.sources.each do |source|
+          sources.each do |source|
             match = match_in_source(source, provider_model, model_name, normalized)
             return match if match
           end

data/lib/llm_cost_tracker/pricing/mode.rb

@@ -4,8 +4,8 @@ module LlmCostTracker
   module Pricing
     module Mode
       STANDARD_MODE_VALUES = %w[auto default standard standard_only unspecified].freeze
-      COMPOUND_MODIFIERS = %w[data_residency].freeze
       KNOWN_MODIFIERS = %w[batch flex priority scale fast on_demand data_residency].freeze
+      HOST_DERIVED_MODIFIERS = %w[data_residency].freeze
       MAX_PERMUTED_MODIFIERS = 6
 
       def self.normalize(value)
@@ -23,7 +23,7 @@ module LlmCostTracker
         return normalize(request_mode) if provider_mode.to_s.strip.empty?
 
         provider_tokens = tokenize(provider_mode) - STANDARD_MODE_VALUES
-        request_host_tokens = tokenize(request_mode || "") & COMPOUND_MODIFIERS
+        request_host_tokens = tokenize(request_mode || "") & HOST_DERIVED_MODIFIERS
         combined = provider_tokens | request_host_tokens
         return nil if combined.empty?
 
@@ -41,12 +41,12 @@ module LlmCostTracker
         loop do
           break if remaining.empty?
 
-          compound = COMPOUND_MODIFIERS.find do |token|
-            remaining == token || remaining.start_with?("#{token}_")
+          known = KNOWN_MODIFIERS.find do |modifier|
+            remaining == modifier || remaining.start_with?("#{modifier}_")
           end
-          if compound
-            tokens << compound
-            remaining = remaining.delete_prefix(compound).delete_prefix("_")
+          if known
+            tokens << known
+            remaining = remaining.delete_prefix(known).delete_prefix("_")
           else
             first, _, rest = remaining.partition("_")
             tokens << first unless first.empty?

data/lib/llm_cost_tracker/pricing/rate.rb

@@ -9,8 +9,7 @@ module LlmCostTracker
       "per_1k_requests" => 1_000,
       "per_session" => 1,
       "per_hour" => 1,
-      "per_minute" => 1,
-      "per_image" => 1
+      "per_minute" => 1
     }.freeze
 
     Rate = Data.define(:amount, :quantity, :currency, :source, :source_key, :source_version)

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -101,7 +101,7 @@ module LlmCostTracker
         end
 
         def prices_file_mtime_iso
-          path = LlmCostTracker.configuration.prices_file
+          path = LlmCostTracker.configuration.pricing.file
           return nil unless path && File.exist?(path)
 
           @prices_file_mtime_iso ||= File.mtime(path).utc.iso8601
@@ -113,16 +113,16 @@ module LlmCostTracker
             [
               Source.new(
                 name: "pricing_overrides",
-                prices: config.pricing_overrides,
+                prices: config.pricing.overrides,
                 rates: {},
                 currency: upcased_currency(nil),
                 version: "configuration"
               ),
               Source.new(
                 name: "prices_file",
-                prices: file_prices(config.prices_file),
-                rates: file_rates(config.prices_file),
-                currency: upcased_currency(file_metadata(config.prices_file)["currency"]),
+                prices: file_prices(config.pricing.file),
+                rates: file_rates(config.pricing.file),
+                currency: upcased_currency(file_metadata(config.pricing.file)["currency"]),
                 version: prices_file_mtime_iso
               ),
               Source.new(

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -26,7 +26,7 @@ module LlmCostTracker
           output = env["OUTPUT"].to_s.strip.presence
           return output if output
 
-          prices_file = config.prices_file
+          prices_file = config.pricing.file
           return prices_file.to_s if prices_file
 
           Rails.root.join(DEFAULT_OUTPUT_PATH).to_s

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -9,14 +9,14 @@ module LlmCostTracker
       WARN_CACHE_LIMIT = 1024
 
       class << self
-        def process(model)
+        def process(model, pricing_mode: nil)
           model = model.to_s.presence || Event::UNKNOWN_MODEL
 
-          case LlmCostTracker.configuration.unknown_pricing_behavior
+          case LlmCostTracker.configuration.pricing.unknown_model_behavior
           when :ignore
             nil
           when :warn
-            warn_missing(model)
+            warn_missing(model, pricing_mode.to_s.presence)
           when :raise
             raise UnknownPricingError.new(model: model)
           end
@@ -24,19 +24,22 @@ module LlmCostTracker
 
         private
 
-        def warn_missing(model)
+        def warn_missing(model, pricing_mode)
+          key = [model, pricing_mode].freeze
           should_warn = MUTEX.synchronize do
             @warned_models ||= Set.new
-            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(model)
+            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(key)
 
-            @warned_models.add?(model)
+            @warned_models.add?(key)
           end
           return unless should_warn
 
+          subject = "model #{model.inspect}"
+          subject += " at pricing_mode #{pricing_mode.inspect}" if pricing_mode
           Logging.warn(
-            "No pricing configured for model #{model.inspect}. " \
+            "No pricing configured for #{subject}. " \
             "Cost and budget guardrails will be skipped for this event. " \
-            "Add a pricing_overrides entry or set unknown_pricing_behavior."
+            "Add a pricing.overrides entry or set pricing.unknown_model_behavior."
           )
         end
       end

data/lib/llm_cost_tracker/providers/anthropic/usage_extractor.rb

@@ -22,12 +22,13 @@ module LlmCostTracker
             output_tokens: output,
             cache_read_input_tokens: cache_read,
             cache_write_input_tokens: cache_write,
-            cache_write_extended_input_tokens: cache_write_extended
+            cache_write_extended_input_tokens: cache_write_extended,
+            hidden_output_tokens: usage.dig(:output_tokens_details, :thinking_tokens).to_i
           )
         end
 
         def self.pricing_mode(request:, usage:)
-          speed = request&.dig(:speed)
+          speed = usage&.dig(:speed) || request&.dig(:speed)
           service_tier = usage&.dig(:service_tier) || request&.dig(:service_tier)
           geo = (usage&.dig(:inference_geo) || request&.dig(:inference_geo)).to_s.downcase
 

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

@@ -4,9 +4,6 @@ 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/
@@ -19,10 +16,6 @@ module LlmCostTracker
         NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
 
         CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN = /-search-(?:preview|api)\b/i
-        def self.data_residency?(model)
-          model.to_s.match?(DATA_RESIDENCY_MODEL_PATTERN)
-        end
-
         def self.image_output?(model)
           model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
         end

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

@@ -16,7 +16,10 @@ module LlmCostTracker
         class << self
           def combined_pricing_mode(host:, model:, service_tier:)
             modes = [Pricing::Mode.normalize(service_tier)]
-            modes << "data_residency" if Hosts.data_residency?(host) && ModelFamilies.data_residency?(model)
+            if Hosts.data_residency?(host) &&
+               Pricing::Matcher.modifier_priced?(provider: "openai", model: model, modifier: "data_residency")
+              modes << "data_residency"
+            end
             Pricing::Mode.compose(modes)
           end
 
@@ -26,7 +29,7 @@ module LlmCostTracker
 
             model = response["model"] || request["model"]
             service_line_items =
-              ServiceCharges.service_line_items_for(response, request: request, model: response["model"]) +
+              ServiceCharges.service_line_items_for(response, request: request, model: model) +
               ServiceCharges.transcription_line_items(usage)
             Event.build(
               provider: provider,

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

@@ -12,6 +12,7 @@ module LlmCostTracker
           input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
           output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
           cache_read = cache_read_input_tokens(usage)
+          cache_write = cache_write_input_tokens(usage)
           audio_input = audio_input_tokens(usage)
           audio_output = audio_output_tokens(usage)
           image_input = image_input_tokens(usage)
@@ -24,10 +25,11 @@ module LlmCostTracker
           )
 
           Usage::TokenUsage.build(
-            input_tokens: [input_tokens - cache_read - audio_input - image_input, 0].max,
+            input_tokens: [input_tokens - cache_read - cache_write - audio_input - image_input, 0].max,
             output_tokens: regular_output,
             total_tokens: usage[:total_tokens],
             cache_read_input_tokens: cache_read,
+            cache_write_input_tokens: cache_write,
             audio_input_tokens: audio_input,
             audio_output_tokens: audio_output,
             image_input_tokens: image_input,
@@ -46,12 +48,11 @@ module LlmCostTracker
             return default_to_image ? [remainder, 0] : [0, remainder]
           end
 
-          text_output = text_output_details
-          text_output = [output_tokens - image_output_details - audio_output, 0].max if text_output.zero?
-          [image_output_details, text_output]
+          [image_output_details, [output_tokens - image_output_details - audio_output, 0].max]
         end
 
         def self.cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
+        def self.cache_write_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cache_write_tokens)
         def self.hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
         def self.audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
         def self.audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)

data/lib/llm_cost_tracker/providers/openai_compatible/parser.rb

@@ -14,7 +14,7 @@ module LlmCostTracker
           end
 
           def provider_names
-            custom = LlmCostTracker.configuration.openai_compatible_providers.each_value.map do |provider|
+            custom = LlmCostTracker.configuration.capture.openai_compatible_providers.each_value.map do |provider|
               provider.to_s.downcase
             end
             ["openai_compatible", *custom].uniq
@@ -23,7 +23,7 @@ module LlmCostTracker
           def provider_for_uri(uri)
             return nil unless uri
 
-            LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
+            LlmCostTracker.configuration.capture.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
           end
         end
 

data/lib/llm_cost_tracker/railtie.rb

@@ -8,14 +8,10 @@ module LlmCostTracker
       app.config.eager_load_paths << models_path unless app.config.eager_load_paths.include?(models_path)
     end
 
+    GENERATOR_FILES = File.expand_path("generators/llm_cost_tracker/*_generator.rb", __dir__)
+
     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/async_ingestion_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"
+      Dir[GENERATOR_FILES].each { |path| require path }
     end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -34,7 +34,7 @@ module LlmCostTracker
         end
         from = now - days.days
         scope = LlmCostTracker::Call.where(tracked_at: from..now)
-        tag_breakdowns ||= LlmCostTracker.configuration.report_tag_breakdowns || []
+        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys || []
         aggregate = totals(scope)
 
         new(
@@ -55,7 +55,7 @@ module LlmCostTracker
       def self.totals(scope)
         scope
           .select(
-            "COALESCE(SUM(total_cost), 0) AS total_cost, " \
+            "COALESCE(SUM(#{LlmCostTracker::Call.qualified(:total_cost)}), 0) AS total_cost, " \
             "COUNT(*) AS requests_count, " \
             "AVG(latency_ms) AS average_latency_ms, " \
             "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \

data/lib/llm_cost_tracker/retention.rb

@@ -3,6 +3,8 @@
 module LlmCostTracker
   module Retention
     DEFAULT_BATCH_SIZE = 5_000
+    ROLLUP_COLUMNS = %i[tracked_at total_cost pricing_snapshot provider].freeze
+    private_constant :ROLLUP_COLUMNS
 
     class << self
       def prune(older_than:, batch_size: DEFAULT_BATCH_SIZE, now: Time.now.utc)
@@ -26,11 +28,23 @@ module LlmCostTracker
         require_relative "ingestion"
         return 0 unless LlmCostTracker::Ingestion::InboxEntry.table_exists?
 
-        LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff).delete_all
+        scope = LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff)
+        warn_undrained(scope.pending)
+        scope.delete_all
       end
 
       private
 
+      def warn_undrained(scope)
+        count, cost = scope.pick(Arel.sql("COUNT(*)"), Arel.sql("COALESCE(SUM(total_cost), 0)"))
+        return if count.to_i.zero?
+
+        Logging.warn(
+          "Retention.prune_inbox is deleting #{count} inbox row(s) worth #{cost} that were never drained " \
+          "into the ledger. Their spend is lost. Drain the inbox before pruning, or raise the retention window."
+        )
+      end
+
       def resolve_cutoff(older_than, now)
         cutoff = case older_than
                  when Time, DateTime then older_than.utc
@@ -58,22 +72,20 @@ module LlmCostTracker
 
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
-          cache_rollups = LlmCostTracker.configuration.cache_rollups
-          rows = prunable_rows(cutoff, batch_size, with_rollup_columns: cache_rollups)
+          rows = prunable_rows(cutoff, batch_size)
           next 0 if rows.empty?
 
-          ids = cache_rollups ? rows.map(&:id) : rows
-          deleted = LlmCostTracker::Call.where(id: ids).delete_all
-          LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
+          deleted = LlmCostTracker::Call.where(id: rows.map(&:id)).delete_all
+          LlmCostTracker::Ledger::Rollups.decrement!(rows) if deleted.positive?
           deleted
         end
       end
 
-      def prunable_rows(cutoff, batch_size, with_rollup_columns:)
+      def prunable_rows(cutoff, batch_size)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-        return relation.pluck(:id) unless with_rollup_columns
-
-        relation.select(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider).to_a
+        columns = [:id]
+        columns += ROLLUP_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
+        relation.select(*columns).to_a
       end
     end
   end

data/lib/llm_cost_tracker/tags/context.rb

@@ -18,15 +18,15 @@ module LlmCostTracker
 
         def tags
           config = LlmCostTracker.configuration
-          base = config.static_sanitized_default_tags ||
-                 Sanitizer.call(call_default_tags(config.default_tags).to_h)
+          base = config.tags.static_sanitized_default ||
+                 Sanitizer.call(call_default_tags(config.tags.default).to_h)
           base.merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
         end
 
         def call_default_tags(proc_or_lambda)
           proc_or_lambda.call
         rescue StandardError => e
-          Logging.warn("LlmCostTracker default_tags proc raised: #{e.class}: #{e.message}; using empty default tags")
+          Logging.warn("LlmCostTracker tags.default proc raised: #{e.class}: #{e.message}; using empty default tags")
           {}
         end
       end