llm_cost_tracker 0.7.3 → 0.8.0

data/lib/llm_cost_tracker/configuration.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "pricing/registry"
 require_relative "tags/key"
-require_relative "configuration/instrumentation"
 
 module LlmCostTracker
   class Configuration
-    include ConfigurationInstrumentation
-
     OPENAI_COMPATIBLE_PROVIDERS = {
       "openrouter.ai" => "openrouter",
       "api.deepseek.com" => "deepseek",
@@ -16,8 +14,8 @@ module LlmCostTracker
 
     BUDGET_EXCEEDED_BEHAVIORS = %i[notify raise block_requests].freeze
     UNKNOWN_PRICING_BEHAVIORS = %i[ignore warn raise].freeze
-    SHARED_SCALAR_ATTRIBUTES = %i[enabled on_budget_exceeded monthly_budget daily_budget per_call_budget log_level
-                                  prices_file max_tag_count max_tag_value_bytesize].freeze
+    SHARED_SCALAR_ATTRIBUTES = %i[enabled default_tags on_budget_exceeded monthly_budget daily_budget per_call_budget
+                                  log_level prices_file max_tag_count max_tag_value_bytesize].freeze
     SHARED_ENUM_ATTRIBUTES = {
       budget_exceeded_behavior: [BUDGET_EXCEEDED_BEHAVIORS, :notify],
       unknown_pricing_behavior: [UNKNOWN_PRICING_BEHAVIORS, :warn]
@@ -27,9 +25,8 @@ module LlmCostTracker
     attr_reader(
       *SHARED_SCALAR_ATTRIBUTES,
       :budget_exceeded_behavior,
-      :default_tags,
-      :pricing_overrides,
       :instrumented_integrations,
+      :pricing_overrides,
       :report_tag_breakdowns,
       :redacted_tag_keys,
       :unknown_pricing_behavior,
@@ -49,19 +46,14 @@ module LlmCostTracker
       @prices_file        = nil
       @max_tag_count      = 50
       @max_tag_value_bytesize = 1024
-      @pricing_overrides = {}
-      @instrumented_integrations = []
+      self.pricing_overrides = {}
+      @instrumented_integrations = Set.new
       @report_tag_breakdowns = []
       @redacted_tag_keys = DEFAULT_REDACTED_TAG_KEYS.dup
       self.openai_compatible_providers = OPENAI_COMPATIBLE_PROVIDERS
       @finalized = false
     end
 
-    def default_tags=(value)
-      ensure_shared_configuration_mutable!
-      @default_tags = value
-    end
-
     def openai_compatible_providers=(providers)
       ensure_shared_configuration_mutable!
       @openai_compatible_providers = normalize_openai_compatible_providers(providers)
@@ -69,7 +61,9 @@ module LlmCostTracker
 
     def pricing_overrides=(value)
       ensure_shared_configuration_mutable!
-      @pricing_overrides = value
+      @pricing_overrides = Pricing::Registry.normalize_price_table(value || {})
+    rescue ArgumentError => e
+      raise Error, "invalid pricing_overrides: #{e.message}"
     end
 
     def report_tag_breakdowns=(value)
@@ -82,6 +76,15 @@ module LlmCostTracker
       @redacted_tag_keys = Array(value).map(&:to_s)
     end
 
+    def instrument(*names)
+      ensure_shared_configuration_mutable!
+      @instrumented_integrations.merge(normalize_instrumentation_names(names))
+    end
+
+    def instrumented?(name)
+      @instrumented_integrations.include?(name)
+    end
+
     SHARED_SCALAR_ATTRIBUTES.each do |name|
       define_method("#{name}=") do |value|
         ensure_shared_configuration_mutable!
@@ -99,10 +102,12 @@ module LlmCostTracker
     def finalize!
       @default_tags = deep_freeze(@default_tags || {})
       @pricing_overrides = deep_freeze(@pricing_overrides || {})
-      @instrumented_integrations = deep_freeze(@instrumented_integrations || [])
+      @instrumented_integrations = deep_freeze(@instrumented_integrations || Set.new)
       @report_tag_breakdowns = deep_freeze(Array(@report_tag_breakdowns))
       @redacted_tag_keys = deep_freeze(Array(@redacted_tag_keys))
-      @openai_compatible_providers = deep_freeze(@openai_compatible_providers || {})
+      @openai_compatible_providers = deep_freeze(
+        normalize_openai_compatible_providers(@openai_compatible_providers)
+      )
       @finalized = true
       self
     end
@@ -115,7 +120,6 @@ module LlmCostTracker
 
     def normalize_enum(name, value, allowed, default:)
       value = default if value.nil?
-      value = value.to_sym
       return value if allowed.include?(value)
 
       raise Error, "Unknown #{name}: #{value.inspect}. Use one of: #{allowed.join(', ')}"
@@ -127,6 +131,19 @@ module LlmCostTracker
       end
     end
 
+    def normalize_instrumentation_names(names)
+      names = names.flatten
+      integrations = Integrations.names
+      return integrations if names == [:all]
+
+      names.each do |name|
+        next if integrations.include?(name)
+
+        raise Error, "Unknown integration: #{name.inspect}. Use one of: #{integrations.join(', ')}"
+      end
+      names
+    end
+
     def ensure_shared_configuration_mutable!
       return unless finalized?
 
@@ -141,7 +158,7 @@ module LlmCostTracker
           deep_freeze(nested_value)
         end
         value.frozen? ? value : value.freeze
-      when Array
+      when Array, Set
         value.each { |nested_value| deep_freeze(nested_value) }
         value.frozen? ? value : value.freeze
       when String

data/lib/llm_cost_tracker/doctor/cost_drift_check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+require_relative "check"
+require_relative "probe"
+
+module LlmCostTracker
+  class Doctor
+    class CostDriftCheck
+      SAMPLE_SIZE = 200
+      EPSILON = BigDecimal("0.00000001")
+
+      def call
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
+        return unless Probe.table_exists?("llm_cost_tracker_call_line_items")
+
+        sampled = LlmCostTracker::Call
+                  .where.not(total_cost: nil)
+                  .where(cost_status: %w[complete free partial])
+                  .order(id: :desc)
+                  .limit(SAMPLE_SIZE)
+                  .pluck(:id, :total_cost, :cost_status)
+        return Check.new(:ok, "cost drift", "no priced calls to inspect") if sampled.empty?
+
+        line_item_totals = LlmCostTracker::CallLineItem
+                           .where(llm_cost_tracker_call_id: sampled.map(&:first))
+                           .group(:llm_cost_tracker_call_id)
+                           .sum(:cost)
+
+        drifted = sampled.filter_map do |id, total_cost, cost_status|
+          line_total = line_item_totals[id] || BigDecimal("0")
+          header = BigDecimal(total_cost.to_s)
+          next if cost_status == "partial" && header >= line_total
+          next if (header - line_total).abs <= EPSILON
+
+          "##{id}: header=#{header.to_s('F')} line_items=#{line_total.to_s('F')}"
+        end
+
+        if drifted.empty?
+          return Check.new(:ok, "cost drift",
+                           "header total_cost matches line items in #{sampled.size} sampled calls")
+        end
+
+        Check.new(
+          :warn,
+          "cost drift",
+          "header total_cost diverges from line items in #{drifted.size}/#{sampled.size} sampled calls: " \
+          "#{drifted.first(5).join('; ')}#{'; ...' if drifted.size > 5}"
+        )
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor/ingestion_check.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "check"
+require_relative "probe"
 require_relative "../ingestion"
 
 module LlmCostTracker
@@ -9,34 +10,34 @@ module LlmCostTracker
       PENDING_AGE_WARNING_SECONDS = 60
 
       def call
-        return unless table_exists?("llm_api_calls")
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
 
         missing = missing_parts
         if missing.empty?
-          quarantined = quarantined_count
+          inbox = inbox_snapshot
+          quarantined = inbox.try(:quarantined_count).to_i
           if quarantined.positive?
-            return Check.new(:warn, "durable ingestion", "#{quarantined} inbox events quarantined after retries")
+            return Check.new(:warn, "durable ingestion", "#{quarantined} inbox entries quarantined after retries")
           end
 
-          pending = pending_snapshot
-          pending_count = pending.try(:pending_count).to_i
-          oldest_pending_at = pending.try(:oldest_created_at)&.to_time&.utc
+          pending_count = inbox.try(:pending_count).to_i
+          oldest_pending_at = inbox.try(:oldest_pending_at)&.to_time&.utc
           pending_age = oldest_pending_at && (Time.now.utc - oldest_pending_at)
           if pending_count.positive? && pending_age && pending_age >= PENDING_AGE_WARNING_SECONDS
             return Check.new(
               :warn,
               "durable ingestion",
-              "#{pending_count} inbox events pending; oldest pending age #{pending_age.round}s"
+              "#{pending_count} inbox entries pending; oldest pending age #{pending_age.round}s"
             )
           end
 
-          return Check.new(:ok, "durable ingestion", "inbox and ingestor lease tables available")
+          return Check.new(:ok, "durable ingestion", "inbox and ingestion lease tables available")
         end
 
         Check.new(
           :error,
           "durable ingestion",
-          "missing #{missing.join(', ')}; run bin/rails generate llm_cost_tracker:add_ingestion && bin/rails db:migrate"
+          "missing #{missing.join(', ')}; see docs/upgrading.md for the recovery steps"
         )
       end
 
@@ -44,31 +45,22 @@ module LlmCostTracker
 
       def missing_parts
         [
-          table_exists?("llm_cost_tracker_inbox_events") ? nil : "llm_cost_tracker_inbox_events",
-          table_exists?("llm_cost_tracker_ingestor_leases") ? nil : "llm_cost_tracker_ingestor_leases"
-        ].compact
+          LlmCostTracker::Ingestion::InboxEntry.table_name,
+          LlmCostTracker::Ingestion::Lease.table_name
+        ].reject { |table| Probe.table_exists?(table) }
       end
 
-      def table_exists?(name)
-        LlmCostTracker::Ledger::Call.connection.data_source_exists?(name)
-      rescue StandardError
-        false
-      end
-
-      def quarantined_count
-        return 0 unless table_exists?("llm_cost_tracker_inbox_events")
-
-        LlmCostTracker::Ingestion::Event
-          .where("attempts >= ?", LlmCostTracker::Ingestion::Event::MAX_ATTEMPTS)
-          .count
-      rescue StandardError
-        0
-      end
-
-      def pending_snapshot
-        LlmCostTracker::Ingestion::Event
-          .where("attempts < ?", LlmCostTracker::Ingestion::Event::MAX_ATTEMPTS)
-          .select("COUNT(*) AS pending_count, MIN(created_at) AS oldest_created_at")
+      def inbox_snapshot
+        max_attempts = LlmCostTracker::Ingestion::InboxEntry::MAX_ATTEMPTS_BEFORE_QUARANTINE
+        LlmCostTracker::Ingestion::InboxEntry
+          .select(
+            "COALESCE(SUM(CASE WHEN attempts >= #{max_attempts} " \
+            "THEN 1 ELSE 0 END), 0) AS quarantined_count, " \
+            "COALESCE(SUM(CASE WHEN attempts < #{max_attempts} " \
+            "THEN 1 ELSE 0 END), 0) AS pending_count, " \
+            "MIN(CASE WHEN attempts < #{max_attempts} " \
+            "THEN created_at ELSE NULL END) AS oldest_pending_at"
+          )
           .take
       rescue StandardError
         nil

data/lib/llm_cost_tracker/doctor/legacy_audit_check.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "check"
+require_relative "probe"
+require_relative "../ledger"
+
+module LlmCostTracker
+  class Doctor
+    class LegacyAuditCheck
+      WARNING_PERCENT = 10
+
+      def call
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
+        return unless LlmCostTracker::Call.column_names.include?("pricing_snapshot")
+
+        counts = LlmCostTracker::Call
+                 .select(
+                   "COUNT(*) AS total_count, " \
+                   "COALESCE(SUM(CASE WHEN pricing_snapshot IS NULL THEN 1 ELSE 0 END), 0) AS missing_count"
+                 )
+                 .take
+        total = counts.total_count.to_i
+        return if total.zero?
+
+        missing = counts.missing_count.to_i
+        return unless (missing * 100) > (total * WARNING_PERCENT)
+
+        message = "#{missing}/#{total} tracked calls lack pricing_snapshot; " \
+                  "stored totals remain stable but applied rates cannot be audited"
+        Check.new(:warn, "pricing snapshot audit", message)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor/legacy_billing_status_check.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "check"
+require_relative "probe"
+require_relative "../ledger"
+
+module LlmCostTracker
+  class Doctor
+    class LegacyBillingStatusCheck
+      def call
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
+        return unless LlmCostTracker::Call.column_names.include?("cost_status")
+
+        return unless LlmCostTracker::Call.where(cost_status: nil).exists?
+
+        Check.new(:warn, "cost status", "legacy rows without cost_status remain; new rows will populate it")
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor/price_check.rb

@@ -8,7 +8,7 @@ module LlmCostTracker
   class Doctor
     class PriceCheck
       STALE_AFTER_DAYS = 30
-      REFRESH_COMMAND = "run bin/rails llm_cost_tracker:prices:refresh"
+      REFRESH_COMMAND = "refresh the source-controlled prices file with bin/rails llm_cost_tracker:prices:refresh"
 
       def call
         path = LlmCostTracker.configuration.prices_file
@@ -48,7 +48,7 @@ module LlmCostTracker
         Check.new(
           :warn,
           "prices",
-          "using bundled prices updated_at=#{updated_at}; configure prices_file for production"
+          "using bundled prices updated_at=#{updated_at}; commit a prices_file for production releases"
         )
       end
 

data/lib/llm_cost_tracker/doctor/pricing_snapshot_drift_check.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+require_relative "check"
+require_relative "probe"
+
+module LlmCostTracker
+  class Doctor
+    class PricingSnapshotDriftCheck
+      SAMPLE_SIZE = 200
+      EPSILON = BigDecimal("0.00000001")
+
+      def call
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
+        return unless Probe.table_exists?("llm_cost_tracker_call_line_items")
+
+        sampled_ids = LlmCostTracker::Call
+                      .where.not(pricing_snapshot: nil)
+                      .where(cost_status: %w[complete free])
+                      .order(id: :desc)
+                      .limit(SAMPLE_SIZE)
+                      .pluck(:id)
+        return Check.new(:ok, "pricing snapshot drift", "no snapshotted calls to inspect") if sampled_ids.empty?
+
+        calls_by_id = LlmCostTracker::Call.where(id: sampled_ids).index_by(&:id)
+        line_items_by_call = LlmCostTracker::CallLineItem
+                             .where(llm_cost_tracker_call_id: sampled_ids, unit: "token")
+                             .group_by(&:llm_cost_tracker_call_id)
+
+        drifted = sampled_ids.flat_map do |id|
+          call = calls_by_id[id]
+          rates = rates_for(call.pricing_snapshot)
+          next [] if rates.nil? || rates.empty?
+
+          (line_items_by_call[id] || []).filter_map { |item| drift_message_for(item, rates, call_id: id) }
+        end
+
+        return ok_check(sampled_ids.size) if drifted.empty?
+
+        Check.new(
+          :warn,
+          "pricing snapshot drift",
+          "line item cost diverges from pricing_snapshot rate in #{drifted.size} cases across " \
+          "#{sampled_ids.size} sampled calls: #{drifted.first(5).join('; ')}#{'; ...' if drifted.size > 5}"
+        )
+      end
+
+      private
+
+      def ok_check(sample_size)
+        Check.new(:ok, "pricing snapshot drift",
+                  "line item costs match pricing_snapshot rates in #{sample_size} sampled calls")
+      end
+
+      def rates_for(snapshot)
+        rates = snapshot.is_a?(Hash) ? (snapshot["rates"] || snapshot[:rates]) : nil
+        rates.is_a?(Hash) ? rates : nil
+      end
+
+      def drift_message_for(line_item, rates, call_id:)
+        return nil unless line_item.price_key
+
+        rate = rates[line_item.price_key.to_s] || rates[line_item.price_key.to_sym]
+        return nil unless rate.is_a?(Hash)
+
+        rate_amount = decimal(rate["amount"] || rate[:amount])
+        rate_quantity = decimal(rate["quantity"] || rate[:quantity])
+        return nil if rate_amount.nil? || rate_quantity.nil? || rate_quantity.zero?
+
+        expected = (decimal(line_item.quantity) * rate_amount) / rate_quantity
+        actual = decimal(line_item.cost) || BigDecimal("0")
+        return nil if (expected - actual).abs <= EPSILON
+
+        "##{call_id}.#{line_item.price_key}: expected=#{expected.round(8).to_s('F')} stored=#{actual.to_s('F')}"
+      end
+
+      def decimal(value)
+        return nil if value.nil?
+
+        BigDecimal(value.to_s)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor/probe.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../ledger"
+
+module LlmCostTracker
+  class Doctor
+    module Probe
+      module_function
+
+      def table_exists?(name)
+        LlmCostTracker::Call.connection.data_source_exists?(name)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor/schema_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "check"
+require_relative "probe"
+require_relative "../ledger"
+
+module LlmCostTracker
+  class Doctor
+    class SchemaCheck
+      def initialize(name:, schema:, table:)
+        @name = name
+        @schema = schema
+        @table = table
+      end
+
+      def call
+        return unless Probe.table_exists?("llm_cost_tracker_calls")
+
+        errors = @schema.current_schema_errors
+        return Check.new(:ok, @name, "#{@table} exists") if errors.empty?
+
+        Check.new(
+          :error,
+          @name,
+          "current schema required; #{errors.join('; ')}; " \
+          "run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
+        )
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor.rb

@@ -2,24 +2,17 @@
 
 require_relative "ledger"
 require_relative "doctor/check"
+require_relative "doctor/probe"
 require_relative "doctor/ingestion_check"
+require_relative "doctor/legacy_audit_check"
+require_relative "doctor/legacy_billing_status_check"
 require_relative "doctor/price_check"
-require_relative "generators/llm_cost_tracker/add_token_usage_generator"
+require_relative "doctor/schema_check"
+require_relative "doctor/cost_drift_check"
+require_relative "doctor/pricing_snapshot_drift_check"
 
 module LlmCostTracker
   class Doctor
-    COLUMN_GENERATORS = {
-      "event_id" => "bin/rails generate llm_cost_tracker:add_ingestion",
-      "latency_ms" => "bin/rails generate llm_cost_tracker:add_latency_ms",
-      "stream" => "bin/rails generate llm_cost_tracker:add_streaming",
-      "usage_source" => "bin/rails generate llm_cost_tracker:add_streaming",
-      "provider_response_id" => "bin/rails generate llm_cost_tracker:add_provider_response_id"
-    }.merge(
-      Generators::AddTokenUsageGenerator::COLUMN_NAMES.to_h do |column|
-        [column, "bin/rails generate llm_cost_tracker:add_token_usage"]
-      end
-    ).freeze
-
     class << self
       def call
         new.checks
@@ -44,7 +37,17 @@ module LlmCostTracker
         active_record_check,
         table_check,
         column_check,
-        period_totals_check,
+        SchemaCheck.new(name: "call line items", schema: Ledger::Schema::CallLineItems,
+                        table: "llm_cost_tracker_call_line_items").call,
+        SchemaCheck.new(name: "call tags", schema: Ledger::Schema::CallTags,
+                        table: "llm_cost_tracker_call_tags").call,
+        SchemaCheck.new(name: "provider invoices", schema: Ledger::Schema::ProviderInvoices,
+                        table: "llm_cost_tracker_provider_invoices").call,
+        CostDriftCheck.new.call,
+        PricingSnapshotDriftCheck.new.call,
+        LegacyBillingStatusCheck.new.call,
+        LegacyAuditCheck.new.call,
+        call_rollups_check,
         IngestionCheck.new.call,
         PriceCheck.new.call,
         calls_check
@@ -68,7 +71,7 @@ module LlmCostTracker
         return Check.new(
           :ok,
           "capture",
-          "SDK integrations enabled: #{config.instrumented_integrations.join(', ')}"
+          "SDK integrations enabled: #{config.instrumented_integrations.to_a.join(', ')}"
         )
       end
 
@@ -93,68 +96,63 @@ module LlmCostTracker
 
     def table_check
       return unless active_record_available?
-      return Check.new(:ok, "llm_api_calls", "table exists") if llm_api_calls_table?
+      return Check.new(:ok, "llm_cost_tracker_calls", "table exists") if llm_cost_tracker_calls_table?
 
       Check.new(
         :error,
-        "llm_api_calls",
+        "llm_cost_tracker_calls",
         "missing; run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
       )
     end
 
     def column_check
-      return unless llm_api_calls_table?
+      return unless llm_cost_tracker_calls_table?
 
       errors = LlmCostTracker::Ledger::Schema::Calls.current_schema_errors
-      return Check.new(:ok, "llm_api_calls columns", "current") if errors.empty?
-
-      missing = LlmCostTracker::Ledger::Schema::Calls.missing_current_schema_columns
-      generators = missing.filter_map { |column| COLUMN_GENERATORS[column] }.uniq
-      message = "current schema required; #{errors.join('; ')}"
-      message = "#{message}; run #{generators.join(' && ')} && bin/rails db:migrate" if generators.any?
+      return Check.new(:ok, "llm_cost_tracker_calls columns", "current") if errors.empty?
 
-      Check.new(:error, "llm_api_calls columns", message)
+      Check.new(
+        :error,
+        "llm_cost_tracker_calls columns",
+        "schema mismatch: #{errors.join('; ')}; see docs/upgrading.md"
+      )
     end
 
-    def period_totals_check
-      return unless llm_api_calls_table?
+    def call_rollups_check
+      return unless llm_cost_tracker_calls_table?
 
-      errors = LlmCostTracker::Ledger::Schema::PeriodTotals.current_schema_errors
-      return Check.new(:ok, "period totals", "llm_cost_tracker_period_totals exists") if errors.empty?
+      errors = LlmCostTracker::Ledger::Schema::CallRollups.current_schema_errors
+      return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if errors.empty?
 
       Check.new(
         :error,
-        "period totals",
-        "current schema required; #{errors.join('; ')}; " \
-        "run bin/rails generate llm_cost_tracker:add_period_totals && bin/rails db:migrate"
+        "call rollups",
+        "schema mismatch: #{errors.join('; ')}; see docs/upgrading.md"
       )
     end
 
     def calls_check
-      return unless llm_api_calls_table?
+      return unless llm_cost_tracker_calls_table?
 
-      count = LlmCostTracker::Ledger::Call.count
+      snapshot = LlmCostTracker::Call
+                 .select("COUNT(*) AS tracked_call_count, MAX(tracked_at) AS latest_tracked_at")
+                 .take
+      count = snapshot.tracked_call_count.to_i
       return Check.new(:warn, "tracked calls", "none recorded yet") if count.zero?
 
-      latest = LlmCostTracker::Ledger::Call.maximum(:tracked_at)&.utc&.iso8601
+      latest_at = snapshot.latest_tracked_at
+      latest_at = latest_at.to_time if latest_at.respond_to?(:to_time)
+      latest = latest_at&.utc&.iso8601
       Check.new(:ok, "tracked calls", "#{count} recorded; latest #{latest}")
     end
 
     def active_record_available?
-      LlmCostTracker::Ledger::Call.connection
+      LlmCostTracker::Call.connection
       true
     rescue LoadError, StandardError
       false
     end
 
-    def llm_api_calls_table?
-      active_record_available? && table_exists?("llm_api_calls")
-    end
-
-    def table_exists?(name)
-      LlmCostTracker::Ledger::Call.connection.data_source_exists?(name)
-    rescue StandardError
-      false
-    end
+    def llm_cost_tracker_calls_table? = active_record_available? && Probe.table_exists?("llm_cost_tracker_calls")
   end
 end