llm_cost_tracker 0.13.0 → 0.14.1

data/lib/llm_cost_tracker/doctor/ingestion_check.rb

@@ -11,20 +11,20 @@ module LlmCostTracker
         return unless Probe.table_exists?("llm_cost_tracker_calls")
         return inline_check unless LlmCostTracker::Ingestion.async?
 
-        missing = missing_parts
-        return async_ok if missing.empty?
+        problems = missing_parts + drifted_parts
+        return async_ok if problems.empty?
 
         Check.new(
           :error,
           "async ingestion",
-          "missing #{missing.join(', ')}; see docs/upgrading.md for the recovery steps"
+          "#{problems.join('; ')}; see docs/upgrading.md for the recovery steps"
         )
       end
 
       private
 
       def async_ok
-        Check.new(:ok, "async ingestion", "inbox and ingestion lease tables available")
+        Check.new(:ok, "async ingestion", "inbox and ingestion lease tables are on the current schema")
       end
 
       def inline_check
@@ -32,14 +32,14 @@ module LlmCostTracker
         if leftovers.empty?
           return Check.new(:ok,
                            "inline ingestion",
-                           "config.ingestion = :inline; events write directly to the ledger")
+                           "config.ingestion.mode = :inline; events write directly to the ledger")
         end
 
         Check.new(
           :warn,
           "inline ingestion",
-          "config.ingestion = :inline but found unused async ingestion tables: #{leftovers.join(', ')}. " \
-          "Set config.ingestion = :async to keep the inbox path or drop the tables."
+          "config.ingestion.mode = :inline but found unused async ingestion tables: #{leftovers.join(', ')}. " \
+          "Set config.ingestion.mode = :async to keep the inbox path or drop the tables."
         )
       end
 
@@ -48,7 +48,16 @@ module LlmCostTracker
       end
 
       def missing_parts
-        async_tables.reject { |table| Probe.table_exists?(table) }
+        async_tables.reject { |table| Probe.table_exists?(table) }.map { |table| "missing #{table}" }
+      end
+
+      def drifted_parts
+        LlmCostTracker::Ledger::Schema::ASYNC_SCHEMAS.filter_map do |schema, table|
+          next unless Probe.table_exists?(table)
+
+          errors = schema.current_schema_errors
+          "#{table} #{errors.join(', ')}" unless errors.empty?
+        end
       end
 
       def async_tables

data/lib/llm_cost_tracker/doctor/price_check.rb

@@ -11,8 +11,9 @@ module LlmCostTracker
       REFRESH_COMMAND = "refresh the source-controlled prices file with bin/rails llm_cost_tracker:prices:refresh"
 
       def call
-        path = LlmCostTracker.configuration.prices_file
+        path = LlmCostTracker.configuration.pricing.file
         return bundled_check unless path
+        return Check.new(:error, "prices", "#{path} does not exist; #{REFRESH_COMMAND}") unless File.exist?(path)
 
         count = LlmCostTracker::Pricing::Registry.file_prices(path).size
         metadata = LlmCostTracker::Pricing::Registry.file_metadata(path)

data/lib/llm_cost_tracker/doctor.rb

@@ -164,7 +164,7 @@ module LlmCostTracker
 
     def call_rollups_check
       return unless llm_cost_tracker_calls_table?
-      return live_rollups_check unless LlmCostTracker.configuration.cache_rollups
+      return live_rollups_check unless LlmCostTracker.configuration.budgets.totals_source == :cache
 
       errors = LlmCostTracker::Ledger::Schema::CallRollups.current_schema_errors
       return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if errors.empty?
@@ -181,14 +181,14 @@ module LlmCostTracker
         Check.new(
           :warn,
           "call rollups",
-          "cache_rollups=false but llm_cost_tracker_call_rollups exists. " \
-          "Set config.cache_rollups = true to keep budget reads on the rollups fast path or drop the table."
+          "budgets.totals_source=:ledger but llm_cost_tracker_call_rollups exists. " \
+          "Set config.budgets.totals_source = :cache to keep budget reads on the rollups fast path or drop the table."
         )
       else
         Check.new(
           :ok,
           "call rollups",
-          "cache_rollups=false; budget reads aggregate from llm_cost_tracker_calls directly"
+          "budgets.totals_source=:ledger; budget reads aggregate from llm_cost_tracker_calls directly"
         )
       end
     end

data/lib/llm_cost_tracker/engine.rb

@@ -9,6 +9,10 @@ module LlmCostTracker
   class Engine < ::Rails::Engine
     isolate_namespace LlmCostTracker
 
+    initializer "llm_cost_tracker.deprecator" do |app|
+      app.deprecators[:llm_cost_tracker] = LlmCostTracker.deprecator
+    end
+
     initializer "llm_cost_tracker.dashboard_setup_state" do |app|
       app.reloader.to_prepare { LlmCostTracker::Dashboard::SetupState.reset! }
     end

data/lib/llm_cost_tracker/errors.rb

@@ -1,25 +1,45 @@
 # frozen_string_literal: true
 
+require_relative "redaction"
+
 module LlmCostTracker
   class Error < StandardError; end
 
   class InvalidFilterError < Error; end
 
+  class TransactionAbortedError < Error
+    def initialize(error)
+      super(
+        "The database rolled back the whole surrounding transaction while recording LLM usage " \
+        "(#{error.class}: #{Redaction.text(error.message)}); the caller's transaction no longer exists"
+      )
+    end
+  end
+
   class BudgetExceededError < Error
-    attr_reader :total, :budget, :budget_type, :last_event, :stage
+    attr_reader :total, :budget, :budget_type, :last_event, :stage, :scope
 
-    def initialize(budget:, budget_type:, total:, last_event: nil, stage: :post_spend)
+    def initialize(budget:, budget_type:, total:, last_event: nil, stage: :post_spend, scope: nil)
       @total = total
       @budget = budget
       @budget_type = budget_type
       @last_event = last_event
       @stage = stage
+      @scope = scope
 
       super(
-        "LLM #{@budget_type.to_s.tr('_', '-')} budget exceeded: " \
+        "LLM #{@budget_type.to_s.tr('_', '-')} budget exceeded#{scope_suffix}: " \
         "$#{format('%.6f', @total)} / $#{format('%.6f', budget)}"
       )
     end
+
+    private
+
+    def scope_suffix
+      return "" unless @scope
+
+      " for #{@scope[:key]}=#{@scope[:value]}"
+    end
   end
 
   class UnknownPricingError < Error
@@ -31,4 +51,6 @@ module LlmCostTracker
       super("No pricing configured for LLM model: #{model.inspect}")
     end
   end
+
+  CALLER_ERRORS = [BudgetExceededError, UnknownPricingError, TransactionAbortedError].freeze
 end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/async_ingestion_generator.rb

@@ -11,7 +11,7 @@ module LlmCostTracker
       source_root File.expand_path("templates", __dir__)
 
       desc "Creates the async ingestion tables (llm_cost_tracker_ingestion_inbox_entries + _leases). " \
-           "Required when config.ingestion = :async."
+           "Required when config.ingestion.mode = :async."
 
       def create_migration_file
         migration_template(
@@ -25,7 +25,7 @@ module LlmCostTracker
           After migrating, set the following in config/initializers/llm_cost_tracker.rb:
 
             LlmCostTracker.configure do |config|
-              config.ingestion = :async
+              config.ingestion.mode = :async
             end
 
           Without it the async inbox tables stay unused and Tracker keeps writing

data/lib/llm_cost_tracker/generators/llm_cost_tracker/call_rollups_generator.rb

@@ -11,7 +11,7 @@ module LlmCostTracker
       source_root File.expand_path("templates", __dir__)
 
       desc "Creates the optional llm_cost_tracker_call_rollups table for fast budget reads. " \
-           "Required when config.cache_rollups = true."
+           "Required when config.budgets.totals_source = :cache."
 
       def create_migration_file
         migration_template(
@@ -25,7 +25,7 @@ module LlmCostTracker
           After migrating, set the following in config/initializers/llm_cost_tracker.rb:
 
             LlmCostTracker.configure do |config|
-              config.cache_rollups = true
+              config.budgets.totals_source = :cache
             end
 
           Without it Tracker keeps reading budget totals as live SUM aggregates over

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_cost_tracker_async_ingestion.rb.erb

@@ -23,7 +23,6 @@ class CreateLlmCostTrackerAsyncIngestion < ActiveRecord::Migration<%= migration_
 
     add_index :llm_cost_tracker_ingestion_inbox_entries, :event_id, unique: true
     add_index :llm_cost_tracker_ingestion_inbox_entries, [:tracked_at, :attempts]
-    add_index :llm_cost_tracker_ingestion_inbox_entries, [:locked_at, :id]
     add_index :llm_cost_tracker_ingestion_leases, :name, unique: true
   end
 end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_cost_tracker_calls.rb.erb

@@ -74,20 +74,24 @@ class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %
                    foreign_key: { to_table: :llm_cost_tracker_calls, on_delete: :cascade }
       t.string :key, null: false
       t.text :value, null: false
+      t.decimal :total_cost, precision: 20, scale: 8
+      t.datetime :tracked_at
     end
 
     add_index :llm_cost_tracker_calls, :event_id, unique: true
     add_index :llm_cost_tracker_calls, :tracked_at
-    add_index :llm_cost_tracker_calls, [:provider, :tracked_at]
-    add_index :llm_cost_tracker_calls, [:model, :tracked_at]
+    add_index :llm_cost_tracker_calls, %i[provider tracked_at]
+    add_index :llm_cost_tracker_calls, %i[model tracked_at]
     add_index :llm_cost_tracker_calls, :cost_status
     add_index :llm_cost_tracker_calls, :provider_response_id
+    add_index :llm_cost_tracker_calls, :id, name: :index_llm_cost_tracker_calls_on_unpriced,
+                                          where: "total_cost IS NULL"
     add_index :llm_cost_tracker_call_line_items, [:llm_cost_tracker_call_id, :position]
     add_index :llm_cost_tracker_call_tags, :llm_cost_tracker_call_id
     if postgresql?
-      add_index :llm_cost_tracker_call_tags, [:key, :value]
+      add_index :llm_cost_tracker_call_tags, [:key, :value, :tracked_at]
     elsif mysql?
-      add_index :llm_cost_tracker_call_tags, [:key, :value], length: { value: 191 }
+      add_index :llm_cost_tracker_call_tags, [:key, :value, :tracked_at], length: { value: 191 }
     end
   end
 

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/initializer.rb.erb

@@ -4,16 +4,16 @@ LlmCostTracker.configure do |config|
   # Set to false to temporarily disable tracking without removing middleware.
   config.enabled = true
 
-  # LLM Cost Tracker logs warnings through Rails.logger when available.
-  config.log_level = :info
-
   # Tags merged into every event. Use a callable for request/job-time context.
-  config.default_tags = -> { { environment: Rails.env } }
+  config.tags.default = -> { { environment: Rails.env } }
 
   # Tag guardrails keep accidental high-cardinality or sensitive values out of the ledger.
-  # config.max_tag_count = 50
-  # config.max_tag_value_bytesize = 1024
-  # config.redacted_tag_keys = <%= LlmCostTracker::Configuration::DEFAULT_REDACTED_TAG_KEYS.inspect %>
+  # config.tags.max_count = 50
+  # config.tags.max_value_bytesize = 1024
+  # config.tags.redacted_keys = <%= LlmCostTracker::Configuration::Tags::DEFAULT_REDACTED_KEYS.inspect %>
+
+  # Tag keys that get their own cost breakdown in bin/rails llm_cost_tracker:report.
+  # config.tags.report_breakdown_keys = %w[feature user_id]
 
   # Optional SDK integrations. Provider SDK gems are not installed by LLM Cost Tracker.
   # Enabled integrations are checked at boot, so enable only clients your app loads.
@@ -23,35 +23,50 @@ LlmCostTracker.configure do |config|
 
   # Pricing — local file refreshed via bin/rails llm_cost_tracker:prices:refresh
   # plus inline overrides. Rates are per 1M tokens; the snapshot's currency
-  # is read from your prices_file's `metadata.currency` (USD in the bundled
+  # is read from your pricing file's `metadata.currency` (USD in the bundled
   # snapshot — set a different code per file if you maintain non-USD prices).
 <% if options[:prices] -%>
-  config.prices_file = Rails.root.join("config/llm_cost_tracker_prices.yml")
+  config.pricing.file = Rails.root.join("config/llm_cost_tracker_prices.yml")
 <% else -%>
-  # config.prices_file = Rails.root.join("config/llm_cost_tracker_prices.yml")
+  # config.pricing.file = Rails.root.join("config/llm_cost_tracker_prices.yml")
 <% end -%>
-  # config.pricing_overrides = {
+  # config.pricing.overrides = {
   #   "my-custom-model" => { input: 1.00, output: 2.00 }
   # }
   # :warn (default) records token usage with nil cost when a model has no rate.
-  # Use :raise to require known pricing for every model.
-  config.unknown_pricing_behavior = :warn
+  # Use :raise to record and then raise for models that have no rate at all; a model
+  # priced with one component rate missing lands as partial and does not trigger it.
+  config.pricing.unknown_model_behavior = :warn
 
   # Budget guardrails — cumulative monthly/daily and per-call ceilings in USD,
-  # plus behavior on crossing (:notify default fires on_budget_exceeded; :raise
+  # plus behavior on crossing (:notify default fires budgets.on_exceeded; :raise
   # raises after recording; :block_requests preflights supported requests, also
   # estimating the current call's input cost via chars/4 so it can block before
-  # send) and an optional callback. Cap evaluation reads from llm_cost_tracker_calls live;
-  # flip cache_rollups to true at high volume so reads hit the rollups table
-  # instead — generate the table with `bin/rails generate llm_cost_tracker:call_rollups`.
-  # config.monthly_budget = 100.00
-  # config.daily_budget = 10.00
-  # config.per_call_budget = 1.00
-  config.budget_exceeded_behavior = :notify
-  # config.on_budget_exceeded = ->(data) {
+  # send) and an optional callback.
+  # config.budgets.monthly = 100.00
+  # config.budgets.daily = 10.00
+  # config.budgets.per_call = 1.00
+  config.budgets.exceeded_behavior = :notify
+
+  # One budget applied to every distinct value of a tag: each tenant gets its own
+  # 1000 a month, not 1000 shared between them. Declare as many tags as you need; a rule
+  # can set its own behavior and callback instead of following the global ones. Needs the
+  # cost columns from `bin/rails generate llm_cost_tracker:upgrade_per_tag_budgets`.
+  # Budget high-cardinality tags only — a tag with a handful of values covers most of the
+  # ledger, so its check cannot use an index and every call pays for a near-full scan.
+  # config.budgets.per_tag = {
+  #   tenant_id: { monthly: 1000.00, weekly: 300.00 },
+  #   user_id: { daily: 25.00, behavior: :notify }
+  # }
+  # config.budgets.on_exceeded = ->(data) {
   #   Rails.logger.warn("LLM #{data[:budget_type]} budget exceeded: $#{data[:total]} / $#{data[:budget]}")
   # }
-  # config.cache_rollups = true
+
+  # Where budget checks read period spend from. :ledger sums llm_cost_tracker_calls on
+  # every check; :cache also keeps running totals in llm_cost_tracker_call_rollups and
+  # takes the greater of the two, so it guards against drift but does not make checks
+  # faster. Generate the table first with `bin/rails generate llm_cost_tracker:call_rollups`.
+  # config.budgets.totals_source = :cache
 
   # Ingestion path — :inline (default) writes events synchronously from the request
   # thread. Set to :async for a write-ahead inbox + background worker that batches
@@ -59,13 +74,18 @@ LlmCostTracker.configure do |config|
   # inbox/leases tables created by `bin/rails generate llm_cost_tracker:async_ingestion`.
   # Synchronous inbox writes use a dedicated ActiveRecord pool (defaults to 2 connections)
   # so they don't compete with request threads for the default pool when a tracked call
-  # happens inside an open caller transaction. Bump ingestion_pool_size if your Puma
+  # happens inside an open caller transaction. Bump ingestion.pool_size if your Puma
   # worker count outgrows that.
-  # config.ingestion          = :async
-  # config.ingestion_pool_size = 5
+  # config.ingestion.mode = :async
+  # config.ingestion.pool_size = 5
+
+  # Register OpenAI-compatible gateway hosts so their calls are attributed to a
+  # provider name instead of the generic openai_compatible bucket.
+  # config.capture.openai_compatible_providers["llm.my-company.com"] = "internal_gateway"
+
+  # Streaming calls only report token usage when the request asks for it. Leave this
+  # on and the Faraday middleware adds stream_options: { include_usage: true } to
+  # streaming chat-completions requests on hosts known to accept it.
+  # config.capture.request_stream_usage = false
 
-  # Register OpenAI-compatible gateway hosts and choose extra tag breakdowns
-  # for bin/rails llm_cost_tracker:report.
-  # config.openai_compatible_providers["llm.my-company.com"] = "internal_gateway"
-  # config.report_tag_breakdowns = %w[feature user_id]
 end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/upgrade_indexes.rb.erb

@@ -0,0 +1,40 @@
+require "llm_cost_tracker/ledger/schema/adapter"
+
+class UpgradeLlmCostTrackerIndexes < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  CALLS = :llm_cost_tracker_calls
+  INBOX = :llm_cost_tracker_ingestion_inbox_entries
+  UNUSED_INBOX_INDEX = %i[locked_at id].freeze
+  UNPRICED_INDEX = :index_llm_cost_tracker_calls_on_unpriced
+
+  def up
+    add_index CALLS, :id, name: UNPRICED_INDEX, where: "total_cost IS NULL", **add_index_options
+    return unless table_exists?(INBOX)
+
+    remove_index INBOX, column: UNUSED_INBOX_INDEX, **remove_index_options
+  end
+
+  def down
+    add_index INBOX, UNUSED_INBOX_INDEX, **add_index_options if table_exists?(INBOX)
+    remove_index CALLS, name: UNPRICED_INDEX, **remove_index_options
+  end
+
+  private
+
+  def add_index_options
+    return { if_not_exists: true } unless postgresql?
+
+    { if_not_exists: true, algorithm: :concurrently }
+  end
+
+  def remove_index_options
+    return { if_exists: true } unless postgresql?
+
+    { if_exists: true, algorithm: :concurrently }
+  end
+
+  def postgresql?
+    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/upgrade_per_tag_budgets.rb.erb

@@ -0,0 +1,41 @@
+require "llm_cost_tracker/ledger/schema/adapter"
+
+class UpgradeLlmCostTrackerPerTagBudgets < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  TABLE = :llm_cost_tracker_call_tags
+  INDEX = %i[key value tracked_at].freeze
+  REPLACED_INDEX = %i[key value].freeze
+
+  def up
+    add_column TABLE, :total_cost, :decimal, precision: 20, scale: 8 unless column_exists?(TABLE, :total_cost)
+    add_column TABLE, :tracked_at, :datetime unless column_exists?(TABLE, :tracked_at)
+    add_index TABLE, INDEX, **add_index_options
+    remove_index TABLE, column: REPLACED_INDEX, **remove_index_options
+  end
+
+  def down
+    add_index TABLE, REPLACED_INDEX, **add_index_options
+    remove_index TABLE, column: INDEX, **remove_index_options
+    remove_column TABLE, :tracked_at, if_exists: true
+    remove_column TABLE, :total_cost, if_exists: true
+  end
+
+  private
+
+  def add_index_options
+    return { if_not_exists: true, length: { value: 191 } } unless postgresql?
+
+    { if_not_exists: true, algorithm: :concurrently }
+  end
+
+  def remove_index_options
+    return { if_exists: true } unless postgresql?
+
+    { if_exists: true, algorithm: :concurrently }
+  end
+
+  def postgresql?
+    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/upgrade_indexes_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class UpgradeIndexesGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Adds a partial index over unpriced calls and drops the unused ingestion inbox lock index" \
+           "scanning the whole ledger."
+
+      def create_migration_file
+        migration_template(
+          "upgrade_indexes.rb.erb",
+          "db/migrate/upgrade_llm_cost_tracker_indexes.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/upgrade_per_tag_budgets_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class UpgradePerTagBudgetsGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Carries each call's cost and time onto its tag rows so per-tag budgets read " \
+           "llm_cost_tracker_call_tags without a join. Required when config.budgets.per_tag is set."
+
+      def create_migration_file
+        migration_template(
+          "upgrade_per_tag_budgets.rb.erb",
+          "db/migrate/upgrade_llm_cost_tracker_per_tag_budgets.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/ingestion/batch.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "inbox"
+require_relative "../budget"
 require_relative "../ledger/store"
 
 module LlmCostTracker
@@ -12,7 +13,8 @@ module LlmCostTracker
         ActiveRecord::Deadlocked,
         ActiveRecord::LockWaitTimeout,
         ActiveRecord::StatementTimeout,
-        ActiveRecord::ConnectionNotEstablished
+        ActiveRecord::ConnectionNotEstablished,
+        LlmCostTracker::TransactionAbortedError
       ].freeze
 
       def initialize(identity:)
@@ -24,7 +26,7 @@ module LlmCostTracker
         return 0 if rows.empty?
 
         valid_rows, events = decode(rows)
-        persist(valid_rows, events) if events.any?
+        persist_batch(valid_rows, events) if events.any?
         rows.size
       rescue StandardError => e
         rows_to_mark = valid_rows&.any? ? valid_rows : rows
@@ -66,7 +68,7 @@ module LlmCostTracker
       end
 
       def error_message_for(error)
-        "#{error.class}: #{error.message}".byteslice(0, 1_000)
+        "#{error.class}: #{Redaction.text(error.message)}".byteslice(0, 1_000).scrub("")
       end
 
       def warn_on_quarantine(rows)
@@ -74,12 +76,10 @@ module LlmCostTracker
         quarantined = rows.select { |row| row.attempts.to_i + 1 >= threshold }
         return if quarantined.empty?
 
-        sample = quarantined.first(10).map(&:id).join(", ")
-        sample += "..." if quarantined.size > 10
         LlmCostTracker::Logging.warn(
           "Ingestion::Batch: #{quarantined.size} inbox row(s) reached " \
           "MAX_ATTEMPTS_BEFORE_QUARANTINE=#{threshold} and will be skipped " \
-          "on the next claim cycle (ids: #{sample})"
+          "on the next claim cycle (ids: #{id_sample(quarantined)})"
         )
       end
 
@@ -87,6 +87,11 @@ module LlmCostTracker
 
       attr_reader :identity
 
+      def id_sample(rows)
+        sample = rows.first(10).map(&:id).join(", ")
+        rows.size > 10 ? "#{sample}..." : sample
+      end
+
       def claim
         now = Time.now.utc
         cutoff = now - LOCK_TIMEOUT_SECONDS
@@ -116,12 +121,38 @@ module LlmCostTracker
         [valid_rows, events]
       end
 
+      def persist_batch(rows, events)
+        landed = []
+        failed = Hash.new { |hash, message| hash[message] = [] }
+        landed.concat(persist(rows, events))
+      rescue *TRANSIENT_PERSIST_ERRORS
+        raise
+      rescue StandardError
+        rows.zip(events) do |row, event|
+          landed.concat(persist([row], [event]))
+        rescue *TRANSIENT_PERSIST_ERRORS
+          raise
+        rescue StandardError => e
+          failed[error_message_for(e)] << row
+        end
+      ensure
+        failed.each do |message, failed_rows|
+          LlmCostTracker::Logging.warn(
+            "Ingestion::Batch: #{failed_rows.size} inbox row(s) could not be stored " \
+            "(ids: #{id_sample(failed_rows)}): #{message}"
+          )
+          mark_failed_with_message(failed_rows, message)
+        end
+        Ledger::Rollups.increment_safely!(landed)
+        Budget.notify_persisted_safely!(landed)
+      end
+
       def persist(rows, events, retry_on_conflict: true)
         LlmCostTracker::Call.transaction do
           Ledger::Store.persist_records(events)
           Ingestion::InboxEntry.where(id: rows.map(&:id), locked_by: identity).delete_all
         end
-        Ledger::Rollups.increment_safely!(events) if Ingestion.cache_rollups?
+        events
       rescue ActiveRecord::RecordNotUnique
         raise unless retry_on_conflict
 

data/lib/llm_cost_tracker/ingestion/pool.rb

@@ -12,7 +12,14 @@ module LlmCostTracker
         delegate :with_connection, to: :pool
 
         def pool
-          @pool || MUTEX.synchronize { @pool ||= connect! }
+          return @pool if @pool && @pid == Process.pid
+
+          MUTEX.synchronize do
+            next @pool if @pool && @pid == Process.pid
+
+            @pid = Process.pid
+            @pool = connect!
+          end
         end
 
         private
@@ -27,7 +34,7 @@ module LlmCostTracker
         end
 
         def pool_size
-          configured = LlmCostTracker.configuration.ingestion_pool_size.to_i
+          configured = LlmCostTracker.configuration.ingestion.pool_size.to_i
           configured.positive? ? configured : DEFAULT_POOL_SIZE
         end
       end

data/lib/llm_cost_tracker/ingestion.rb

@@ -37,16 +37,12 @@ module LlmCostTracker
       end
 
       def async?
-        LlmCostTracker.configuration.ingestion == :async
-      end
-
-      def cache_rollups?
-        LlmCostTracker.configuration.cache_rollups
+        LlmCostTracker.configuration.ingestion.mode == :async
       end
 
       def guards_for_current_config
         guards = Ledger::Schema::CORE_SCHEMAS.dup
-        guards << Ledger::Schema::CACHE_ROLLUPS_SCHEMA if cache_rollups?
+        guards << Ledger::Schema::CACHE_ROLLUPS_SCHEMA if LlmCostTracker.configuration.budgets.totals_source == :cache
         guards += Ledger::Schema::ASYNC_SCHEMAS if async?
         guards
       end
@@ -132,7 +128,7 @@ module LlmCostTracker
         return if records.empty?
 
         relation.delete_all
-        LlmCostTracker::Ledger::Rollups.decrement!(records) if cache_rollups?
+        LlmCostTracker::Ledger::Rollups.decrement!(records)
       end
 
       def cleanup_verification_inbox(event:, response_id:)