llm_cost_tracker 0.12.0 → 0.14.0

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 = %w[api_key access_token authorization credential password refresh_token secret]
+  # 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 reject 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 keeps running totals in llm_cost_tracker_call_rollups so checks
+  # read one row instead — switch once the live SUM gets slow, and 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
+  # OpenAI-compatible streaming request bodies that don't already set 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
@@ -8,6 +9,12 @@ module LlmCostTracker
     class Batch
       BATCH_SIZE = 100
       LOCK_TIMEOUT_SECONDS = 30
+      TRANSIENT_PERSIST_ERRORS = [
+        ActiveRecord::Deadlocked,
+        ActiveRecord::LockWaitTimeout,
+        ActiveRecord::StatementTimeout,
+        ActiveRecord::ConnectionNotEstablished
+      ].freeze
 
       def initialize(identity:)
         @identity = identity
@@ -22,7 +29,10 @@ module LlmCostTracker
         rows.size
       rescue StandardError => e
         rows_to_mark = valid_rows&.any? ? valid_rows : rows
-        mark_failed_with_message(rows_to_mark, error_message_for(e)) if rows_to_mark&.any?
+        if rows_to_mark&.any?
+          transient = valid_rows&.any? && TRANSIENT_PERSIST_ERRORS.any? { |klass| e.is_a?(klass) }
+          mark_failed_with_message(rows_to_mark, error_message_for(e), decrement_attempts: transient)
+        end
         raise
       end
 
@@ -34,12 +44,20 @@ module LlmCostTracker
         claimable_scope(Time.now.utc - LOCK_TIMEOUT_SECONDS).exists?
       end
 
-      def mark_failed_with_message(rows, message)
+      def mark_failed_with_message(rows, message, decrement_attempts: false)
         now = Time.now.utc
-        Ingestion::InboxEntry
-          .where(id: rows.map(&:id), locked_by: identity)
-          .update_all(last_error: message, locked_at: now, locked_by: nil, updated_at: now)
-        warn_on_quarantine(rows)
+        scope = Ingestion::InboxEntry.where(id: rows.map(&:id), locked_by: identity)
+        if decrement_attempts
+          scope.update_all(
+            Ingestion::InboxEntry.sanitize_sql_array(
+              ["last_error = ?, locked_at = ?, locked_by = NULL, " \
+               "attempts = GREATEST(attempts - 1, 0), updated_at = ?", message, now, now]
+            )
+          )
+        else
+          scope.update_all(last_error: message, locked_at: now, locked_by: nil, updated_at: now)
+          warn_on_quarantine(rows)
+        end
       rescue StandardError => e
         LlmCostTracker::Logging.warn(
           "Inbox mark_failed_with_message failed for #{rows.size} rows: #{e.class}: #{e.message} " \
@@ -101,9 +119,11 @@ module LlmCostTracker
 
       def persist(rows, events, retry_on_conflict: true)
         LlmCostTracker::Call.transaction do
-          Ledger::Store.insert(events)
+          Ledger::Store.persist_records(events)
           Ingestion::InboxEntry.where(id: rows.map(&:id), locked_by: identity).delete_all
         end
+        Ledger::Rollups.increment_safely!(events)
+        Budget.notify_persisted_safely!(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:)

data/lib/llm_cost_tracker/integrations/anthropic.rb

@@ -46,16 +46,17 @@ module LlmCostTracker
 
         def record_batch_result(response)
           return unless active?
-          return unless response.respond_to?(:result) && response.result
 
-          result = response.result
-          return unless result.respond_to?(:type) && result.type.to_s == "succeeded"
+          record_safely do
+            next unless response.respond_to?(:result) && response.result
 
-          message = result.respond_to?(:message) ? result.message : nil
-          return unless message
-          return if LlmCostTracker::Call.already_recorded?(provider: "anthropic", provider_response_id: message.id)
+            result = response.result
+            next unless result.respond_to?(:type) && result.type.to_s == "succeeded"
+
+            message = result.respond_to?(:message) ? result.message : nil
+            next unless message
+            next if LlmCostTracker::Call.already_recorded?(provider: "anthropic", provider_response_id: message.id)
 
-          record_safely do
             usage = message.usage
             next unless usage
             next if usage.input_tokens.nil? && usage.output_tokens.nil?

data/lib/llm_cost_tracker/integrations/base.rb

@@ -83,7 +83,7 @@ module LlmCostTracker
         enforce_budget!(request: request, provider: provider)
         started_at = LlmCostTracker::Timing.now_monotonic
         response = yield
-        record.call(response, request, LlmCostTracker::Timing.elapsed_ms(started_at))
+        record_safely { record.call(response, request, LlmCostTracker::Timing.elapsed_ms(started_at)) }
         response
       end
 

data/lib/llm_cost_tracker/integrations/openai/batch_capture.rb

@@ -13,32 +13,30 @@ module LlmCostTracker
         class << self
           def maybe_capture(batch, resource:)
             return unless Openai.active?
-            return unless batch.respond_to?(:status) && batch.status.to_s == "completed"
-
-            output_file_id = batch.respond_to?(:output_file_id) ? batch.output_file_id : nil
-            return unless output_file_id
-
-            batch_id = batch.respond_to?(:id) ? batch.id : nil
-            return unless batch_id && claim(batch_id)
+            return unless batch.status.to_s == "completed"
+            return unless batch.output_file_id && batch.id
+            return if captured?(batch.id)
 
             client = resource.instance_variable_get(:@client)
             host = Openai.client_host_for(resource)
             Openai.record_safely do
-              io = client.files.content(output_file_id)
+              io = client.files.content(batch.output_file_id)
               capture_jsonl(io.respond_to?(:read) ? io.read : io.to_s, host: host)
+              mark_captured(batch.id)
             end
           end
 
           private
 
-          def claim(batch_id)
+          def captured?(batch_id)
+            MUTEX.synchronize { @dedup&.include?(batch_id) || false }
+          end
+
+          def mark_captured(batch_id)
             MUTEX.synchronize do
               @dedup ||= Set.new
-              next false if @dedup.include?(batch_id)
-
               @dedup.clear if @dedup.size >= DEDUP_LIMIT
               @dedup.add(batch_id)
-              true
             end
           end
 

data/lib/llm_cost_tracker/ledger/period/totals.rb

@@ -45,7 +45,7 @@ module LlmCostTracker
 
         def recorded_sql(period, start)
           calls = "COALESCE(#{sum_sql(LlmCostTracker::Call.between(start, time))}, 0)"
-          return calls unless LlmCostTracker.configuration.cache_rollups
+          return calls unless Rollups.cache_active?
 
           rollup = "COALESCE(#{sum_sql(rollup_scope(period))}, 0)"
           "GREATEST(#{rollup}, #{calls})"

data/lib/llm_cost_tracker/ledger/rollups.rb

@@ -8,7 +8,17 @@ module LlmCostTracker
   module Ledger
     module Rollups
       class << self
+        def cache_active?
+          return false unless LlmCostTracker.configuration.budgets.totals_source == :cache
+          return true if LlmCostTracker::CallRollup.table_exists?
+
+          warn_missing_table
+          false
+        end
+
         def increment!(events)
+          return unless cache_active?
+
           events = Array(events).select(&:total_cost)
           return if events.empty?
 
@@ -18,7 +28,9 @@ module LlmCostTracker
         ROLLUP_INCREMENT_ATTEMPTS = 3
         ROLLUP_INCREMENT_BASE_DELAY_SECONDS = 0.05
         REBUILD_INSERT_SLICE = 1_000
-        private_constant :ROLLUP_INCREMENT_ATTEMPTS, :ROLLUP_INCREMENT_BASE_DELAY_SECONDS, :REBUILD_INSERT_SLICE
+        private_constant :ROLLUP_INCREMENT_ATTEMPTS,
+                         :ROLLUP_INCREMENT_BASE_DELAY_SECONDS,
+                         :REBUILD_INSERT_SLICE
 
         def increment_safely!(events)
           attempt = 0
@@ -28,19 +40,26 @@ module LlmCostTracker
           rescue StandardError => e
             raise if LlmCostTracker::Call.connection.open_transactions.positive?
 
-            if attempt < ROLLUP_INCREMENT_ATTEMPTS
+            if attempt < ROLLUP_INCREMENT_ATTEMPTS && rolled_back?(e)
               sleep(ROLLUP_INCREMENT_BASE_DELAY_SECONDS * (2**(attempt - 1)))
               retry
             end
 
             LlmCostTracker::Logging.warn(
-              "Rollup increment failed for #{events.size} events after #{attempt} attempts: " \
-              "#{e.class}: #{e.message}"
+              "Rollup increment failed for #{events.size} events after #{attempt} attempt(s): " \
+              "#{e.class}: #{e.message}. Budget reads fall back to the calls ledger; " \
+              "run bin/rails llm_cost_tracker:rebuild_rollups to resync the cache."
             )
           end
         end
 
+        def rolled_back?(error)
+          error.is_a?(ActiveRecord::Deadlocked) || error.is_a?(ActiveRecord::LockWaitTimeout)
+        end
+
         def decrement!(records)
+          return unless cache_active?
+
           buckets = bucket_totals(records)
           return if buckets.empty?
 
@@ -60,6 +79,17 @@ module LlmCostTracker
 
         private
 
+        def warn_missing_table
+          return if @missing_table_warned
+
+          @missing_table_warned = true
+          Logging.warn(
+            "config.budgets.totals_source = :cache is set but llm_cost_tracker_call_rollups is missing; " \
+            "budget and dashboard totals fall back to aggregating llm_cost_tracker_calls. " \
+            "Run the call_rollups generator and migrate, or set config.budgets.totals_source = :ledger."
+          )
+        end
+
         def accumulate_priced_calls
           accumulated = Hash.new { |totals, key| totals[key] = BigDecimal("0") }
           priced_calls.in_batches do |batch|

data/lib/llm_cost_tracker/ledger/store.rb

@@ -4,6 +4,7 @@ require "json"
 
 require_relative "../pricing"
 require_relative "rollups"
+require_relative "../budget/per_tag"
 require_relative "tags/encoding"
 
 module LlmCostTracker
@@ -14,13 +15,20 @@ module LlmCostTracker
           events = Array(events)
           return if events.empty?
 
+          persist_records(events)
+          Ledger::Rollups.increment_safely!(events)
+        end
+
+        def persist_records(events)
+          events = Array(events)
+          return if events.empty?
+
           LlmCostTracker::Call.transaction do
             rows = events.map { |event| attributes_for(event) }
             call_ids = insert_calls_returning_ids(rows, events)
             insert_line_items(events, call_ids)
             insert_call_tags(events, call_ids)
           end
-          Ledger::Rollups.increment_safely!(events) if LlmCostTracker.configuration.cache_rollups
         end
 
         private
@@ -114,7 +122,7 @@ module LlmCostTracker
                 llm_cost_tracker_call_id: call_ids.fetch(event.event_id),
                 key: key.to_s,
                 value: Tags::Encoding.encode(value)
-              }
+              }.merge(budget_columns_for(event))
             end
           end
           return if rows.empty?
@@ -122,6 +130,12 @@ module LlmCostTracker
           LlmCostTracker::CallTag.insert_all!(rows, record_timestamps: false, returning: false)
         end
 
+        def budget_columns_for(event)
+          return {} unless LlmCostTracker::Budget::PerTag.columns?
+
+          { total_cost: event.cost&.total, tracked_at: event.tracked_at }
+        end
+
         def stored_details(details)
           (details || {}).transform_keys(&:to_s).transform_values { |value| Tags::Encoding.normalize_value(value) }
         end

data/lib/llm_cost_tracker/ledger/tags/encoding.rb

@@ -6,12 +6,22 @@ module LlmCostTracker
   module Ledger
     module Tags
       module Encoding
+        INDEXABLE_BYTES = 2_048
+
         def self.encode(value)
-          case value
-          when Hash then JSON.generate(normalize_hash(value))
-          when Array then JSON.generate(normalize_array(value))
-          else value.to_s
-          end
+          encoded = case value
+                    when Hash then JSON.generate(normalize_hash(value))
+                    when Array then JSON.generate(normalize_array(value))
+                    else value.to_s
+                    end
+          truncate(encoded)
+        end
+
+        def self.truncate(string)
+          limit = [LlmCostTracker.configuration.tags.max_value_bytesize.to_i, INDEXABLE_BYTES].min
+          return string if string.bytesize <= limit
+
+          string.byteslice(0, limit).encode("UTF-8", invalid: :replace, undef: :replace)
         end
 
         def self.normalize_hash(hash)

data/lib/llm_cost_tracker/logging.rb

@@ -3,15 +3,13 @@
 module LlmCostTracker
   module Logging
     class << self
-      def debug(message) = tagged.debug(message)
+      def debug(message) = Rails.logger.debug(prefixed(message))
 
-      def warn(message) = tagged.warn(message)
+      def warn(message) = Rails.logger.warn(prefixed(message))
 
       private
 
-      def tagged
-        Rails.logger.tagged(LlmCostTracker.name)
-      end
+      def prefixed(message) = "[#{LlmCostTracker.name}] #{message}"
     end
   end
 end

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -94,7 +94,7 @@ module LlmCostTracker
       end
 
       def inject_stream_usage_flag(request_env, parser, request_url, request_parsed)
-        return nil unless LlmCostTracker.configuration.auto_enable_stream_usage
+        return nil unless LlmCostTracker.configuration.capture.request_stream_usage
         return nil unless parser&.auto_enable_stream_usage?(request_url)
 
         stream_options = request_parsed["stream_options"]