llm_cost_tracker 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3bb624cf9437e2ab972021128ab552b48b16c9b8d209429fb264062837e8547
-  data.tar.gz: 8785221213ed888a592b312e5a734193637653930ef9652ece73f650cb920eb5
+  metadata.gz: ec6d42366ce33ab5b2d4847d4ad425dd4d4262a302212427be2a3fc55db53fcc
+  data.tar.gz: 57f6eaa22546be19cc3b17afeed107fb35782ad5de4b6ed9646a4d7955cab589
 SHA512:
-  metadata.gz: c223c14dbfe3e2ebf61930175ae7607c2a4a05f502962963312c4ec929965242fccab115eda9d1426d6e331d7fb23ad811f73c9ba8a795cb3262c3d49a60eb45
-  data.tar.gz: 6b8e3ef019f41907909bb9f07eb58085dd6355a442699d52440de564c97fb6fb65979ee01271e4741bd9411ce7ef6a3b69102accd764fdf419d42db1bdb2f6e8
+  metadata.gz: 716c326903ac571988211ee34f2ff2a43d6cec3d6b8d00a1682df5d245877e7884f8b3e3b3e9d86e37b0089a73f97f3dc1b4c7cbbf1c40a1365702acef7e5f6b
+  data.tar.gz: ef41e457bafea063396e7ab08d2c7f6c051c1831ec7476071e36b08af7812853c7e1501fc4d7986658de726316c136e562b747eec26316ffd97a7ee6ee7eda2a

data/CHANGELOG.md

@@ -4,6 +4,24 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [S
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-06-26
+
+### Added
+
+- The Data Quality page shows quarantined async-inbox rows (count and cost) when `ingestion: :async` is configured, so cost stuck outside the ledger is visible instead of silently missing from totals.
+
+### Changed
+
+- BREAKING: `LlmCostTracker.track(tokens:)` and `stream.usage` (inside `track_stream`) now raise `ArgumentError` on unrecognized token keys instead of dropping them, so a typo like `outpt_tokens:` surfaces immediately rather than undercounting the ledger.
+- OpenAI's image-generation, computer-use, and MCP tool calls no longer add `$0` line items that marked a call's pricing `partial`. Their cost is already captured in the model's tokens, so these tool calls are no longer recorded as separate rows and the call reflects complete pricing.
+
+### Fixed
+
+- The mounted dashboard no longer returns 404 — the engine now registers its routes during Rails boot.
+- Async ingestion (`config.ingestion = :async`) no longer permanently loses cost data when a transient database error (deadlock, lock timeout, dropped connection) interrupts the worker mid-drain — affected inbox rows are retried instead of counting toward quarantine.
+- With `config.cache_rollups`, a failed rollup-cache update no longer fails or retries the async ingestion batch — calls land in the ledger, the failure is logged, and `bin/rails llm_cost_tracker:rebuild_rollups` recovers the cached totals.
+- The dashboard labels non-USD amounts with their currency code (e.g. `1.23 EUR`) instead of always rendering `$`, on the pricing table and per-line call costs.
+
 ## [0.12.0] - 2026-06-04
 
 ### Added

data/app/controllers/llm_cost_tracker/data_quality_controller.rb

@@ -20,6 +20,7 @@ module LlmCostTracker
         scope,
         total_streaming: @summary.streaming_count
       )
+      @quarantined_inbox = Dashboard::DataQuality.quarantined_inbox
     end
   end
 end

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -32,15 +32,17 @@ module LlmCostTracker
       (numerator.to_f / denominator) * 100.0
     end
 
-    def money(value)
+    def money(value, currency: LlmCostTracker::DEFAULT_CURRENCY)
       value = value.to_f
       precision = value.abs < 0.01 && value != 0.0 ? 6 : 2
+      formatted = format("%.#{precision}f", value)
+      code = currency.to_s.upcase.presence || LlmCostTracker::DEFAULT_CURRENCY
 
-      "$#{format("%.#{precision}f", value)}"
+      code == LlmCostTracker::DEFAULT_CURRENCY ? "$#{formatted}" : "#{formatted} #{code}"
     end
 
-    def optional_money(value)
-      value.nil? ? "n/a" : money(value)
+    def optional_money(value, currency: LlmCostTracker::DEFAULT_CURRENCY)
+      value.nil? ? "n/a" : money(value, currency: currency)
     end
 
     def format_date(value)

data/app/models/llm_cost_tracker/ingestion/inbox_entry.rb

@@ -6,6 +6,7 @@ module LlmCostTracker
       MAX_ATTEMPTS_BEFORE_QUARANTINE = 5
 
       scope :pending, -> { where(attempts: ..(MAX_ATTEMPTS_BEFORE_QUARANTINE - 1)) }
+      scope :quarantined, -> { where(attempts: MAX_ATTEMPTS_BEFORE_QUARANTINE..) }
     end
   end
 end

data/app/services/llm_cost_tracker/dashboard/data_quality.rb

@@ -4,6 +4,7 @@ module LlmCostTracker
   module Dashboard
     module DataQuality
       UnknownPricingRow = ::Data.define(:provider, :model, :calls, :share_percent)
+      QuarantinedInbox = ::Data.define(:count, :total_cost)
       StreamingHealthRow = ::Data.define(:provider, :streams, :with_usage, :unknown, :unknown_share)
       Summary = ::Data.define(:total,
                               :unknown_pricing_count,
@@ -33,6 +34,17 @@ module LlmCostTracker
           scope.unscope(:order).select(aggregate_selects(scope)).take
         end
 
+        def quarantined_inbox
+          return nil unless Ingestion.async?
+          return nil unless Ingestion::InboxEntry.table_exists?
+
+          row = Ingestion::InboxEntry
+                .quarantined
+                .select("COUNT(*) AS quarantined_count, COALESCE(SUM(total_cost), 0) AS quarantined_cost")
+                .take
+          QuarantinedInbox.new(count: row.quarantined_count.to_i, total_cost: row.quarantined_cost.to_d)
+        end
+
         def summary(stats)
           total = stats.total_calls.to_i
           unknown_pricing_count = stats.unknown_pricing_count.to_i

data/app/views/llm_cost_tracker/calls/show.html.erb

@@ -142,9 +142,9 @@ end %>
             <td><code class="lct-code-id"><%= line_item.kind %></code></td>
             <td><%= line_item.unit %></td>
             <td class="lct-num"><%= line_item.quantity %></td>
-            <td class="lct-num"><%= line_item.rate_amount ? "#{optional_money(line_item.rate_amount)} / #{line_item.rate_quantity}" : "n/a" %></td>
+            <td class="lct-num"><%= line_item.rate_amount ? "#{optional_money(line_item.rate_amount, currency: line_item.currency)} / #{line_item.rate_quantity}" : "n/a" %></td>
             <% unknown_cost = line_item.cost.nil? || line_item.cost_status.to_s == LlmCostTracker::Charges::CostStatus::UNKNOWN %>
-            <td class="lct-num<%= ' lct-num-muted' if unknown_cost %>"><%= unknown_cost ? "n/a" : money(line_item.cost) %></td>
+            <td class="lct-num<%= ' lct-num-muted' if unknown_cost %>"><%= unknown_cost ? "n/a" : money(line_item.cost, currency: line_item.currency) %></td>
             <td><%= line_item.cost_status %></td>
           </tr>
         <% end %>

data/app/views/llm_cost_tracker/data_quality/index.html.erb

@@ -10,6 +10,17 @@
   <span class="lct-filter-row-meta"><%= number_with_delimiter(@summary.total) %> call<%= "s" unless @summary.total == 1 %> inspected</span>
 </div>
 
+<% if @quarantined_inbox && @quarantined_inbox.count.positive? %>
+  <h3 class="lct-stat-section-label">Async inbox</h3>
+  <div class="lct-stat-grid">
+    <div class="lct-stat lct-stat-warn">
+      <div class="lct-stat-head"><p class="lct-stat-label">Quarantined inbox rows</p></div>
+      <p class="lct-stat-value"><%= number_with_delimiter(@quarantined_inbox.count) %></p>
+      <p class="lct-stat-foot"><%= money(@quarantined_inbox.total_cost) %> excluded from the ledger and totals</p>
+    </div>
+  </div>
+<% end %>
+
 <% if @summary.total.zero? %>
   <section class="lct-panel lct-empty">
     <h2 class="lct-state-title">No data yet</h2>

data/app/views/llm_cost_tracker/pricing/index.html.erb

@@ -83,7 +83,7 @@
             <td><code class="lct-code-id"><%= row.model %></code></td>
             <% LlmCostTracker::Dashboard::PricingOverview::RATE_COLUMNS.each do |key| %>
               <% value = row.rates[key] %>
-              <td class="lct-num<%= ' lct-num-muted' if value.nil? %>"><%= value ? money(value) : "—" %></td>
+              <td class="lct-num<%= ' lct-num-muted' if value.nil? %>"><%= value ? money(value, currency: @source_data.fetch(:currency)) : "—" %></td>
             <% end %>
           </tr>
         <% end %>

data/lib/llm_cost_tracker/capture/stream_collector.rb

@@ -79,7 +79,7 @@ module LlmCostTracker
           @provider_api_key_id = extra.delete(:provider_api_key_id) || @provider_api_key_id
           @provider_workspace_id = extra.delete(:provider_workspace_id) || @provider_workspace_id
           @explicit_usage = Usage::TokenUsage.build(
-            **extra.slice(*Usage::TokenUsage.members),
+            **extra,
             input_tokens: input_tokens,
             output_tokens: output_tokens
           )
@@ -121,13 +121,14 @@ module LlmCostTracker
         save_succeeded = false
         begin
           event = build_event(snapshot)
-          provider_response_id = event.provider_response_id || snapshot[:provider_response_id]
-          event = event.with(provider_response_id: provider_response_id)
+          event = event.with(
+            provider_response_id: event.provider_response_id || snapshot[:provider_response_id],
+            pricing_mode: Pricing::Mode.merge(event.pricing_mode, snapshot[:pricing_mode])
+          )
 
           Tracker.record(
             event: event,
             latency_ms: snapshot[:latency_ms] || LlmCostTracker::Timing.elapsed_ms(@started_at),
-            pricing_mode: Pricing::Mode.merge(event.pricing_mode, snapshot[:pricing_mode]),
             metadata: (errored ? { stream_errored: true } : {}).merge(snapshot[:metadata]),
             context_tags: snapshot[:context_tags]
           ) { save_succeeded = true }

data/lib/llm_cost_tracker/charges/line_item.rb

@@ -119,8 +119,9 @@ module LlmCostTracker
       end
 
       def dimension
-        Usage::Catalog[price_key] ||
-          Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
+        Usage::Catalog.find_by(
+          kind: kind, direction: direction, modality: modality, cache_state: cache_state, unit: unit
+        )
       end
 
       def cost_value

data/lib/llm_cost_tracker/event.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "pricing/mode"
+
 module LlmCostTracker
   Event = Data.define(
     :event_id,
@@ -48,7 +50,7 @@ module LlmCostTracker
     end
 
     def batch?
-      pricing_mode.to_s.split("_").include?("batch")
+      Pricing::Mode.tokenize(pricing_mode.to_s).include?("batch")
     end
 
     def self.resolve_line_items(service_items)

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

@@ -13,7 +13,7 @@ LlmCostTracker.configure do |config|
   # 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.redacted_tag_keys = <%= LlmCostTracker::Configuration::DEFAULT_REDACTED_TAG_KEYS.inspect %>
 
   # 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.

data/lib/llm_cost_tracker/ingestion/batch.rb

@@ -8,6 +8,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 +28,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 +43,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 +118,10 @@ 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) if Ingestion.cache_rollups?
       rescue ActiveRecord::RecordNotUnique
         raise unless retry_on_conflict
 

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/ledger/store.rb

@@ -14,13 +14,20 @@ module LlmCostTracker
           events = Array(events)
           return if events.empty?
 
+          persist_records(events)
+          Ledger::Rollups.increment_safely!(events) if LlmCostTracker.configuration.cache_rollups
+        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