llm_cost_tracker 0.7.3 → 0.9.0

data/lib/llm_cost_tracker/integrations/ruby_llm.rb

@@ -25,7 +25,7 @@ module LlmCostTracker
             patch_target(
               "RubyLLM::Provider",
               with: ProviderPatch,
-              methods: %i[slug complete embed transcribe]
+              methods: %i[slug complete embed transcribe paint moderate]
             )
           ]
         end
@@ -65,6 +65,69 @@ module LlmCostTracker
           )
         end
 
+        def record_image(provider, response, request:, latency_ms:)
+          usage = object_value(response, :usage)
+          usage = {} unless usage.is_a?(Hash)
+          raw_input = (usage[:input_tokens] || usage["input_tokens"]).to_i
+          raw_output = (usage[:output_tokens] || usage["output_tokens"]).to_i
+          image_input = image_token_detail(usage, :input)
+          image_output = image_token_detail(usage, :output)
+          text_input = [raw_input - image_input, 0].max
+          text_output = [raw_output - image_output, 0].max
+          record_passthrough(
+            provider: provider_slug(provider),
+            model: response_model_id(response) || model_id(request[:model]),
+            response: response,
+            latency_ms: latency_ms,
+            input_tokens: text_input,
+            image_input_tokens: image_input,
+            output_tokens: text_output,
+            image_output_tokens: image_output
+          )
+        end
+
+        def record_moderation(provider, response, request:, latency_ms:)
+          record_passthrough(
+            provider: provider_slug(provider),
+            model: response_model_id(response) || model_id(request[:model]),
+            response: response,
+            latency_ms: latency_ms,
+            input_tokens: 0,
+            output_tokens: 0
+          )
+        end
+
+        def image_token_detail(usage, direction)
+          container_key = direction == :input ? :input_tokens_details : :output_tokens_details
+          details = usage[container_key] || usage[container_key.to_s] || {}
+          return 0 unless details.is_a?(Hash)
+
+          (details[:image_tokens] || details["image_tokens"]).to_i
+        end
+
+        def record_passthrough(provider:, model:, response:, latency_ms:, input_tokens:, output_tokens:,
+                               image_input_tokens: 0, image_output_tokens: 0)
+          return unless active?
+
+          record_safely do
+            LlmCostTracker::Tracker.record(
+              capture: UsageCapture.build(
+                provider: provider,
+                model: model,
+                token_usage: TokenUsage.build(
+                  input_tokens: input_tokens,
+                  output_tokens: output_tokens,
+                  image_input_tokens: image_input_tokens,
+                  image_output_tokens: image_output_tokens
+                ),
+                usage_source: :sdk_response,
+                provider_response_id: provider_response_id(response)
+              ),
+              latency_ms: latency_ms
+            )
+          end
+        end
+
         def record_usage(provider:, model:, response:, latency_ms:, stream:, output_tokens: nil)
           return unless active?
 
@@ -80,7 +143,7 @@ module LlmCostTracker
               capture: UsageCapture.build(
                 provider: provider,
                 model: model,
-                pricing_mode: pricing_mode(response),
+                pricing_mode: pricing_mode(provider: provider, response: response),
                 token_usage: TokenUsage.build(
                   input_tokens: regular_input_tokens(input_tokens, cache_read),
                   output_tokens: output_tokens.to_i,
@@ -89,7 +152,7 @@ module LlmCostTracker
                   hidden_output_tokens: hidden_output
                 ),
                 stream: stream,
-                usage_source: :ruby_llm,
+                usage_source: :sdk_response,
                 provider_response_id: provider_response_id(response)
               ),
               latency_ms: latency_ms
@@ -98,7 +161,7 @@ module LlmCostTracker
         end
 
         def regular_input_tokens(input_tokens, cache_read)
-          [input_tokens.to_i - cache_read.to_i, 0].max
+          [input_tokens.to_i - cache_read, 0].max
         end
 
         def provider_slug(provider)
@@ -122,10 +185,16 @@ module LlmCostTracker
           object_value(response, :id, :provider_response_id) || object_dig(response, :raw, :id)
         end
 
-        def pricing_mode(response)
-          object_value(response, :pricing_mode, :service_tier) ||
-            object_dig(response, :raw, :pricing_mode) ||
-            object_dig(response, :raw, :service_tier)
+        ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS = %w[standard standard_only priority].freeze
+        private_constant :ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS
+
+        def pricing_mode(provider:, response:)
+          raw = object_value(response, :pricing_mode, :service_tier) ||
+                object_dig(response, :raw, :pricing_mode) ||
+                object_dig(response, :raw, :service_tier)
+          return nil if provider == "anthropic" && ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS.include?(raw.to_s)
+
+          raw
         end
       end
 
@@ -133,8 +202,8 @@ module LlmCostTracker
         def complete(*args, **kwargs, &)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           integration.enforce_budget!
+          started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_completion(
             self,
@@ -149,8 +218,8 @@ module LlmCostTracker
         def embed(*args, **kwargs)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           integration.enforce_budget!
+          started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_embedding(
             self,
@@ -164,8 +233,8 @@ module LlmCostTracker
         def transcribe(*args, **kwargs)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           integration.enforce_budget!
+          started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_transcription(
             self,
@@ -175,6 +244,36 @@ module LlmCostTracker
           )
           response
         end
+
+        def paint(*args, **kwargs)
+          integration = LlmCostTracker::Integrations::RubyLlm
+          request = integration.request_params(args, kwargs)
+          integration.enforce_budget!
+          started_at = LlmCostTracker::Timing.now_monotonic
+          response = super
+          integration.record_image(
+            self,
+            response,
+            request: request,
+            latency_ms: integration.elapsed_ms(started_at)
+          )
+          response
+        end
+
+        def moderate(*args, **kwargs)
+          integration = LlmCostTracker::Integrations::RubyLlm
+          request = integration.request_params(args, kwargs)
+          integration.enforce_budget!
+          started_at = LlmCostTracker::Timing.now_monotonic
+          response = super
+          integration.record_moderation(
+            self,
+            response,
+            request: request,
+            latency_ms: integration.elapsed_ms(started_at)
+          )
+          response
+        end
       end
     end
   end

data/lib/llm_cost_tracker/integrations.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "logging"
 require_relative "integrations/openai"
 require_relative "integrations/anthropic"
 require_relative "integrations/ruby_llm"
@@ -13,10 +14,14 @@ module LlmCostTracker
       ruby_llm: RubyLlm
     }.freeze
 
+    DOUBLE_INSTRUMENTATION_OVERLAPS = %i[openai anthropic].freeze
+
     module_function
 
     def install!(names = LlmCostTracker.configuration.instrumented_integrations)
-      normalize(names).each { |name| fetch(name).install }
+      normalized = normalize(names)
+      warn_double_instrumentation(normalized)
+      normalized.each { |name| fetch(name).install }
     end
 
     def checks(names = LlmCostTracker.configuration.instrumented_integrations)
@@ -26,11 +31,24 @@ module LlmCostTracker
     end
 
     def normalize(names)
-      Array(names).flatten.map(&:to_sym).uniq
+      Array(names).flatten.uniq
+    end
+
+    def warn_double_instrumentation(names)
+      return unless names.include?(:ruby_llm)
+
+      overlapping = names & DOUBLE_INSTRUMENTATION_OVERLAPS
+      return if overlapping.empty?
+
+      Logging.warn(
+        ":ruby_llm is enabled together with #{overlapping.map(&:inspect).join(', ')}. " \
+        "RubyLLM uses HTTP underneath, so calls routed to those providers may be recorded twice " \
+        "(once via the SDK patch, once via the Faraday parser). Pick one path per provider."
+      )
     end
 
     def fetch(name)
-      AVAILABLE.fetch(name.to_sym) do
+      AVAILABLE.fetch(name) do
         message = "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
         raise LlmCostTracker::Error, message
       end

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

@@ -27,38 +27,57 @@ module LlmCostTracker
 
         def snapshot_totals
           values = periods.to_h { |period| [period, 0.0] }
+          period_by_name = periods.to_h { |period| [period.name, period] }
           sql = periods.map { |period| snapshot_select(period) }.join(" UNION ALL ")
-          LlmCostTracker::Ledger::Call.find_by_sql(sql).each do |row|
-            values[row.period_key.to_sym] = row.total_cost.to_f
+          LlmCostTracker::Call.find_by_sql(sql).each do |row|
+            period = period_by_name.fetch(row.period_key)
+            values[period] = row.total_cost.to_f
           end
           values
         end
 
         def snapshot_select(period)
           start = Period.range_start(period, time)
-          "SELECT #{connection.quote(period.to_s)} AS period_key, " \
-            "(#{rollup_total_sql(period)}) + (#{pending_total_sql(start)}) AS total_cost"
+          components = [period_total_sql(period, start)]
+          components << pending_total_sql(start) if Ingestion.durable?
+          "SELECT #{connection.quote(period.name)} AS period_key, " \
+            "(#{components.join(') + (')}) AS total_cost"
         end
 
-        def rollup_total_sql(period)
-          table = connection.quote_table_name("llm_cost_tracker_period_totals")
-          "COALESCE((SELECT total_cost FROM #{table} " \
+        def period_total_sql(period, start)
+          if LlmCostTracker.configuration.cache_rollups
+            "GREATEST(COALESCE(#{rollup_sum_sql(period)}, 0), COALESCE(#{calls_sum_sql(start)}, 0))"
+          else
+            "COALESCE(#{calls_sum_sql(start)}, 0)"
+          end
+        end
+
+        def rollup_sum_sql(period)
+          table = connection.quote_table_name("llm_cost_tracker_call_rollups")
+          "(SELECT SUM(total_cost) FROM #{table} " \
             "WHERE period = #{connection.quote(Period::PERIODS.fetch(period))} " \
-            "AND period_start = #{connection.quote(Period.bucket(period, time))} LIMIT 1), 0)"
+            "AND period_start = #{connection.quote(Period.bucket(period, time))})"
+        end
+
+        def calls_sum_sql(start)
+          table = connection.quote_table_name("llm_cost_tracker_calls")
+          tracked_at = connection.quote_column_name("tracked_at")
+          "(SELECT SUM(total_cost) FROM #{table} " \
+            "WHERE #{tracked_at} BETWEEN #{connection.quote(start)} AND #{connection.quote(time)})"
         end
 
         def pending_total_sql(start)
-          table = connection.quote_table_name(Ingestion::Event.table_name)
+          table = connection.quote_table_name(Ingestion::InboxEntry.table_name)
           total_cost = connection.quote_column_name("total_cost")
           tracked_at = connection.quote_column_name("tracked_at")
           attempts = connection.quote_column_name("attempts")
           "COALESCE((SELECT SUM(#{total_cost}) FROM #{table} " \
-            "WHERE #{attempts} < #{Ingestion::Event::MAX_ATTEMPTS} " \
+            "WHERE #{attempts} < #{Ingestion::InboxEntry::MAX_ATTEMPTS_BEFORE_QUARANTINE} " \
             "AND #{tracked_at} BETWEEN #{connection.quote(start)} AND #{connection.quote(time)}), 0)"
         end
 
         def connection
-          LlmCostTracker::Ledger::Call.connection
+          LlmCostTracker::Call.connection
         end
       end
     end

data/lib/llm_cost_tracker/ledger/period.rb

@@ -4,22 +4,22 @@ module LlmCostTracker
   module Ledger
     module Period
       PERIODS = {
-        monthly: "month",
-        daily:   "day"
+        month: "month",
+        day:   "day"
       }.freeze
 
       module_function
 
       def valid_keys(periods)
-        periods.map(&:to_sym).select { |period| PERIODS.key?(period) }
+        periods.select { |period| PERIODS.key?(period) }
       end
 
       def range_start(period, time)
         utc_time = time.to_time.utc
 
         case period
-        when :monthly then utc_time.beginning_of_month
-        when :daily then utc_time.beginning_of_day
+        when :month then utc_time.beginning_of_month
+        when :day then utc_time.beginning_of_day
         end
       end
 

data/lib/llm_cost_tracker/ledger/rollups/upsert_sql.rb

@@ -23,7 +23,7 @@ module LlmCostTracker
           total_cost = connection.quote_column_name("total_cost")
           updated_at = connection.quote_column_name("updated_at")
 
-          "#{total_cost} = #{Period::Total.quoted_table_name}.#{total_cost} + excluded.#{total_cost}, " \
+          "#{total_cost} = #{LlmCostTracker::CallRollup.quoted_table_name}.#{total_cost} + excluded.#{total_cost}, " \
             "#{updated_at} = excluded.#{updated_at}"
         end
 
@@ -32,7 +32,7 @@ module LlmCostTracker
         end
 
         def connection
-          Period::Total.connection
+          LlmCostTracker::CallRollup.connection
         end
       end
     end

data/lib/llm_cost_tracker/ledger/rollups.rb

@@ -3,34 +3,25 @@
 require "bigdecimal"
 
 require_relative "period"
-require_relative "rollups/batch"
 require_relative "rollups/upsert_sql"
 
 module LlmCostTracker
   module Ledger
     class Rollups
+      DEFAULT_CURRENCY = "USD"
+
       class << self
         def increment!(event)
           return unless event.total_cost
 
-          Period::Total.upsert_all(
-            period_rows(event),
-            on_duplicate: Ledger::Rollups::UpsertSql.call,
-            record_timestamps: true,
-            unique_by: period_totals_unique_by
-          )
+          upsert_call_rollups(period_rows(event))
         end
 
         def increment_many!(events)
           events = Array(events).select(&:total_cost)
           return if events.empty?
 
-          Period::Total.upsert_all(
-            Ledger::Rollups::Batch.rows(events),
-            on_duplicate: Ledger::Rollups::UpsertSql.call,
-            record_timestamps: true,
-            unique_by: period_totals_unique_by
-          )
+          upsert_call_rollups(period_rows_for_events(events))
         end
 
         def decrement!(call_rows)
@@ -43,43 +34,117 @@ module LlmCostTracker
         private
 
         def period_rows(event)
+          currency = currency_for(event)
+          provider = provider_for(event)
           Period::PERIODS.map do |period, name|
             {
               period: name,
               period_start: Period.bucket(period, event.tracked_at),
+              currency: currency,
+              provider: provider,
               total_cost: event.total_cost
             }
           end
         end
 
+        def period_rows_for_events(events)
+          call_rollups(events).map do |(period, period_start, currency, provider), total_cost|
+            {
+              period: period,
+              period_start: period_start,
+              currency: currency,
+              provider: provider,
+              total_cost: total_cost
+            }
+          end
+        end
+
+        def call_rollups(events)
+          events.each_with_object(Hash.new { |totals, key| totals[key] = BigDecimal("0") }) do |event, totals|
+            currency = currency_for(event)
+            provider = provider_for(event)
+            Period::PERIODS.each do |period, name|
+              key = [name, Period.bucket(period, event.tracked_at), currency, provider]
+              totals[key] += BigDecimal(event.total_cost.to_s)
+            end
+          end
+        end
+
         def period_decrement_totals(call_rows)
           call_rows.each_with_object(Hash.new { |totals, key| totals[key] = BigDecimal("0") }) do |row, totals|
-            _id, tracked_at, total_cost = row
+            _id, tracked_at, total_cost, pricing_snapshot, provider = row
             next unless total_cost
 
+            currency = currency_from_snapshot(pricing_snapshot)
+            provider_key = provider.to_s
             Period::PERIODS.each_key do |period|
-              totals[[period, Period.bucket(period, tracked_at)]] += BigDecimal(total_cost.to_s)
+              totals[[period, Period.bucket(period, tracked_at), currency, provider_key]] += total_cost
             end
           end
         end
 
         def apply_decrements(totals)
           now = Time.now.utc
+          buckets_by_period = totals.each_with_object({}) do |(key, amount), grouped|
+            period, period_start, currency, provider = key
+            grouped[[period, currency, provider]] ||= {}
+            grouped[[period, currency, provider]][period_start] = amount
+          end
 
-          totals.each do |(period, period_start), amount|
-            row = Period::Total.lock.find_by(period: Period::PERIODS.fetch(period),
-                                             period_start: period_start)
-            next unless row
-
-            row.update_columns(total_cost: [BigDecimal(row.total_cost.to_s) - amount, BigDecimal("0")].max,
-                               updated_at: now)
+          conn = LlmCostTracker::CallRollup.connection
+          table = LlmCostTracker::CallRollup.quoted_table_name
+          period_col = conn.quote_column_name("period")
+          start_col = conn.quote_column_name("period_start")
+          currency_col = conn.quote_column_name("currency")
+          provider_col = conn.quote_column_name("provider")
+          total_col = conn.quote_column_name("total_cost")
+          updated_col = conn.quote_column_name("updated_at")
+
+          buckets_by_period.each do |(period, currency, provider), by_start|
+            case_clauses = by_start.map do |period_start, amount|
+              "WHEN #{start_col} = #{conn.quote(period_start)} THEN #{conn.quote(amount)}"
+            end.join(" ")
+            starts = by_start.keys.map { |period_start| conn.quote(period_start) }.join(", ")
+
+            conn.execute(
+              "UPDATE #{table} " \
+              "SET #{total_col} = GREATEST(0, #{total_col} - CASE #{case_clauses} ELSE 0 END), " \
+              "#{updated_col} = #{conn.quote(now)} " \
+              "WHERE #{period_col} = #{conn.quote(Period::PERIODS.fetch(period))} " \
+              "AND #{currency_col} = #{conn.quote(currency)} " \
+              "AND #{provider_col} = #{conn.quote(provider)} " \
+              "AND #{start_col} IN (#{starts})"
+            )
           end
         end
 
-        def period_totals_unique_by
-          return unless Period::Total.connection.supports_insert_conflict_target?
+        def currency_for(event)
+          snapshot = event.respond_to?(:pricing_snapshot) ? event.pricing_snapshot : nil
+          currency_from_snapshot(snapshot)
+        end
+
+        def currency_from_snapshot(snapshot)
+          value = (snapshot.is_a?(Hash) && (snapshot["currency"] || snapshot[:currency])) || DEFAULT_CURRENCY
+          value.to_s.upcase
+        end
+
+        def provider_for(event)
+          (event.respond_to?(:provider) ? event.provider : nil).to_s
+        end
+
+        def upsert_call_rollups(rows)
+          LlmCostTracker::CallRollup.upsert_all(
+            rows,
+            on_duplicate: Ledger::Rollups::UpsertSql.call,
+            record_timestamps: true,
+            unique_by: call_rollups_unique_by
+          )
+        end
+
+        def call_rollups_unique_by
+          return unless LlmCostTracker::CallRollup.connection.supports_insert_conflict_target?
 
-          %i[period period_start]
+          %i[period period_start currency provider]
         end
       end
     end

data/lib/llm_cost_tracker/ledger/schema/adapter.rb

@@ -32,6 +32,24 @@ module LlmCostTracker
             raise Error, "Unsupported database adapter: #{adapter_name(value)}. Use PostgreSQL or MySQL."
           end
 
+          def json_column_errors(column, adapter_value, column_name)
+            return [] unless column
+
+            expected_type = postgresql?(adapter_value) ? "jsonb" : "json"
+            return [] if json_column_type?(column, adapter_value)
+
+            ["#{column_name} column must use #{expected_type} (got #{column.sql_type})"]
+          end
+
+          def json_column_type?(column, adapter_value)
+            sql_type = column.sql_type.to_s.downcase
+            if postgresql?(adapter_value)
+              column.type == :jsonb || sql_type == "jsonb"
+            else
+              column.type == :json || sql_type == "json" || sql_type == "longtext"
+            end
+          end
+
           private
 
           def adapter_instance?(value, class_names)

data/lib/llm_cost_tracker/ledger/schema/call_line_items.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+
+module LlmCostTracker
+  module Ledger
+    module Schema
+      module CallLineItems
+        REQUIRED_COLUMNS = %w[
+          llm_cost_tracker_call_id
+          position
+          kind
+          direction
+          modality
+          cache_state
+          quantity
+          unit
+          rate_amount
+          rate_quantity
+          cost
+          currency
+          cost_status
+          pricing_basis
+          price_key
+          price_source
+          price_source_version
+          provider_field
+          provider_item_id
+          details
+          created_at
+        ].freeze
+
+        REQUIRED_INDEX_COLUMNS = [
+          %w[llm_cost_tracker_call_id position]
+        ].freeze
+
+        class << self
+          def current_schema_errors
+            connection = LlmCostTracker::Call.connection
+            Adapter.ensure_supported!(connection)
+            table_name = LlmCostTracker::CallLineItem.table_name
+            return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
+
+            columns = LlmCostTracker::CallLineItem.columns_hash
+            errors = []
+            missing = REQUIRED_COLUMNS - columns.keys
+            errors << "missing columns: #{missing.join(', ')}" if missing.any?
+            errors.concat(Adapter.json_column_errors(columns["details"], connection, "details"))
+            errors.concat(missing_index_errors(connection, table_name))
+            errors << missing_fk_error(connection, table_name) if missing_fk?(connection, table_name)
+            errors.compact
+          end
+
+          def missing_index_errors(connection, table_name)
+            existing = connection.indexes(table_name).map { |index| Array(index.columns).map(&:to_s) }
+            REQUIRED_INDEX_COLUMNS.filter_map do |required|
+              next if existing.any? { |columns| columns == required }
+
+              "missing index on (#{required.join(', ')})"
+            end
+          end
+
+          def missing_fk?(connection, table_name)
+            connection.foreign_keys(table_name).none? do |fk|
+              fk.column.to_s == "llm_cost_tracker_call_id" &&
+                fk.to_table.to_s == "llm_cost_tracker_calls"
+            end
+          rescue NotImplementedError, NoMethodError
+            false
+          end
+
+          def missing_fk_error(_connection, _table_name)
+            "missing foreign key on llm_cost_tracker_call_id referencing llm_cost_tracker_calls"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/ledger/schema/call_rollups.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+
+module LlmCostTracker
+  module Ledger
+    module Schema
+      module CallRollups
+        REQUIRED_COLUMNS = %w[period period_start currency provider total_cost created_at updated_at].freeze
+        UNIQUE_COLUMNS = %i[period period_start currency provider].freeze
+
+        class << self
+          def current_schema_errors
+            connection = LlmCostTracker::CallRollup.connection
+            Adapter.ensure_supported!(connection)
+            table_name = LlmCostTracker::CallRollup.table_name
+            return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
+
+            errors = []
+            missing = REQUIRED_COLUMNS - LlmCostTracker::CallRollup.columns_hash.keys
+            errors << "missing columns: #{missing.join(', ')}" if missing.any?
+            unless unique_period_index?(connection, table_name)
+              errors << "missing unique index: period, period_start, currency, provider"
+            end
+            errors
+          end
+
+          private
+
+          def unique_period_index?(connection, table_name)
+            connection.index_exists?(table_name, UNIQUE_COLUMNS, unique: true)
+          end
+        end
+      end
+    end
+  end
+end