llm_cost_tracker 0.1.1 → 0.1.3

data/lib/llm_cost_tracker/pricing.rb

@@ -1,108 +1,134 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  # Prices per 1M tokens in USD.
-  # Updated: April 2026. Override via configuration.
+  # Calculates costs from price entries expressed in USD per 1M tokens.
   module Pricing
-    PRICES = {
-      # OpenAI
-      "gpt-5.2"            => { input: 1.75,  cached_input: 0.175, output: 14.00 },
-      "gpt-5.1"            => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gpt-5"              => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gpt-5-mini"         => { input: 0.25,  cached_input: 0.025, output: 2.00 },
-      "gpt-5-nano"         => { input: 0.05,  cached_input: 0.005, output: 0.40 },
-      "gpt-4.1"            => { input: 2.00,  cached_input: 0.50,  output: 8.00 },
-      "gpt-4.1-mini"       => { input: 0.40,  cached_input: 0.10,  output: 1.60 },
-      "gpt-4.1-nano"       => { input: 0.10,  cached_input: 0.025, output: 0.40 },
-      "gpt-4o-2024-05-13"  => { input: 5.00,  output: 15.00 },
-      "gpt-4o"             => { input: 2.50,  cached_input: 1.25,  output: 10.00 },
-      "gpt-4o-mini"        => { input: 0.15,  cached_input: 0.075, output: 0.60 },
-      "gpt-4-turbo"        => { input: 10.00, output: 30.00 },
-      "gpt-4"              => { input: 30.00, output: 60.00 },
-      "gpt-3.5-turbo"      => { input: 0.50,  output: 1.50 },
-      "o1"                 => { input: 15.00, cached_input: 7.50,  output: 60.00 },
-      "o1-mini"            => { input: 1.10,  cached_input: 0.55,  output: 4.40 },
-      "o3"                 => { input: 2.00,  cached_input: 0.50,  output: 8.00 },
-      "o3-mini"            => { input: 1.10,  cached_input: 0.55,  output: 4.40 },
-      "o4-mini"            => { input: 1.10,  cached_input: 0.275, output: 4.40 },
-
-      # Anthropic
-      "claude-sonnet-4-6"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-opus-4-6"    => { input: 5.00,  output: 25.00, cache_read_input: 0.50, cache_creation_input: 6.25 },
-      "claude-opus-4-1"    => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-      "claude-opus-4"      => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-      "claude-sonnet-4-5"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-sonnet-4"    => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-haiku-4-5"   => { input: 1.00,  output: 5.00,  cache_read_input: 0.10, cache_creation_input: 1.25 },
-      "claude-3-7-sonnet"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-3-5-sonnet"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-3-5-haiku"   => { input: 0.80,  output: 4.00,  cache_read_input: 0.08, cache_creation_input: 1.00 },
-      "claude-3-opus"      => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-
-      # Google Gemini
-      "gemini-2.5-pro"     => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gemini-2.5-flash"   => { input: 0.30,  cached_input: 0.03,  output: 2.50 },
-      "gemini-2.5-flash-lite" => { input: 0.10, cached_input: 0.01, output: 0.40 },
-      "gemini-2.0-flash" => { input: 0.10, cached_input: 0.025, output: 0.40 },
-      "gemini-2.0-flash-lite" => { input: 0.075, output: 0.30 },
-      "gemini-1.5-pro"     => { input: 1.25,  output: 5.00 },
-      "gemini-1.5-flash"   => { input: 0.075, output: 0.30 }
-    }.freeze
+    PRICES = PriceRegistry.builtin_prices
+    PRICES_MUTEX = Mutex.new
+    SORTED_PRICE_KEYS_MUTEX = Mutex.new
+
+    private_constant :PRICES_MUTEX
+    private_constant :SORTED_PRICE_KEYS_MUTEX
 
     class << self
+      # Estimate model cost from token counts.
+      #
+      # @param model [String] Provider model identifier.
+      # @param input_tokens [Integer] Input token count, including cached tokens if reported that way.
+      # @param output_tokens [Integer] Output token count.
+      # @param cached_input_tokens [Integer] OpenAI-style cached input tokens.
+      # @param cache_read_input_tokens [Integer] Anthropic-style cache read tokens.
+      # @param cache_creation_input_tokens [Integer] Anthropic-style cache creation tokens.
+      # @return [LlmCostTracker::Cost, nil] nil when no price is configured for the model.
       def cost_for(model:, input_tokens:, output_tokens:, cached_input_tokens: 0,
                    cache_read_input_tokens: 0, cache_creation_input_tokens: 0)
         prices = lookup(model)
         return nil unless prices
 
-        cached_input_tokens = cached_input_tokens.to_i
-        cache_read_input_tokens = cache_read_input_tokens.to_i
-        cache_creation_input_tokens = cache_creation_input_tokens.to_i
-        uncached_input_tokens = [input_tokens.to_i - cached_input_tokens, 0].max
-
-        input_cost = (uncached_input_tokens.to_f / 1_000_000) * prices[:input]
-        cached_input_cost = (cached_input_tokens.to_f / 1_000_000) *
-                            (prices[:cached_input] || prices[:input])
-        cache_read_input_cost = (cache_read_input_tokens.to_f / 1_000_000) *
-                                (prices[:cache_read_input] || prices[:cached_input] || prices[:input])
-        cache_creation_input_cost = (cache_creation_input_tokens.to_f / 1_000_000) *
-                                    (prices[:cache_creation_input] || prices[:input])
-        output_cost = (output_tokens.to_f / 1_000_000) * prices[:output]
-        total_cost = input_cost + cached_input_cost + cache_read_input_cost +
-                     cache_creation_input_cost + output_cost
+        token_counts = normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                               cache_read_input_tokens, cache_creation_input_tokens)
+        costs = calculate_costs(token_counts, prices)
 
-        {
-          input_cost: input_cost.round(8),
-          cached_input_cost: cached_input_cost.round(8),
-          cache_read_input_cost: cache_read_input_cost.round(8),
-          cache_creation_input_cost: cache_creation_input_cost.round(8),
-          output_cost: output_cost.round(8),
-          total_cost: total_cost.round(8),
+        Cost.new(
+          input_cost: costs[:input].round(8),
+          cached_input_cost: costs[:cached_input].round(8),
+          cache_read_input_cost: costs[:cache_read_input].round(8),
+          cache_creation_input_cost: costs[:cache_creation_input].round(8),
+          output_cost: costs[:output].round(8),
+          total_cost: costs.values.sum.round(8),
           currency: "USD"
-        }
+        )
       end
 
       def lookup(model)
-        overrides = LlmCostTracker.configuration.pricing_overrides
-        overrides[model] || PRICES[model] || fuzzy_match(model)
+        table = prices
+        model_name = model.to_s
+        normalized_model = normalize_model_name(model_name)
+
+        table[model_name] || table[normalized_model] || fuzzy_match(model_name, normalized_model, table)
       end
 
       def models
-        PRICES.keys | LlmCostTracker.configuration.pricing_overrides.keys
+        prices.keys
+      end
+
+      def metadata
+        PriceRegistry.metadata
+      end
+
+      def prices
+        file_prices = PriceRegistry.file_prices(LlmCostTracker.configuration.prices_file)
+        overrides = PriceRegistry.normalize_price_table(LlmCostTracker.configuration.pricing_overrides)
+        cache_key = [file_prices.object_id, LlmCostTracker.configuration.pricing_overrides.hash]
+
+        return @prices if @prices_cache_key == cache_key
+
+        PRICES_MUTEX.synchronize do
+          return @prices if @prices_cache_key == cache_key
+
+          @prices_cache_key = cache_key
+          @prices = PRICES.merge(file_prices).merge(overrides).freeze
+        end
       end
 
       private
 
-      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o"
-      def fuzzy_match(model)
-        return nil unless model
+      def normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                  cache_read_input_tokens, cache_creation_input_tokens)
+        cached_input_tokens = cached_input_tokens.to_i
 
-        PRICES.sort_by { |key, _value| -key.length }.each do |key, value|
-          return value if model.start_with?(key)
+        {
+          input: [input_tokens.to_i - cached_input_tokens, 0].max,
+          cached_input: cached_input_tokens,
+          cache_read_input: cache_read_input_tokens.to_i,
+          cache_creation_input: cache_creation_input_tokens.to_i,
+          output: output_tokens.to_i
+        }
+      end
+
+      def calculate_costs(token_counts, prices)
+        {
+          input: token_cost(token_counts[:input], prices[:input]),
+          cached_input: token_cost(token_counts[:cached_input], prices[:cached_input] || prices[:input]),
+          cache_read_input: token_cost(
+            token_counts[:cache_read_input],
+            prices[:cache_read_input] || prices[:cached_input] || prices[:input]
+          ),
+          cache_creation_input: token_cost(
+            token_counts[:cache_creation_input],
+            prices[:cache_creation_input] || prices[:input]
+          ),
+          output: token_cost(token_counts[:output], prices[:output])
+        }
+      end
+
+      def token_cost(tokens, per_million_price)
+        (tokens.to_f / 1_000_000) * per_million_price
+      end
+
+      def normalize_model_name(model)
+        model.to_s.split("/").last
+      end
+
+      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o".
+      def fuzzy_match(model, normalized_model, table)
+        sorted_price_keys(table).each do |key|
+          return table[key] if model.start_with?(key) || normalized_model.start_with?(key)
         end
 
         nil
       end
+
+      def sorted_price_keys(table)
+        return @sorted_price_keys if @sorted_price_keys_table.equal?(table)
+
+        SORTED_PRICE_KEYS_MUTEX.synchronize do
+          return @sorted_price_keys if @sorted_price_keys_table.equal?(table)
+
+          @sorted_price_keys_table = table
+          @sorted_price_keys = table.keys.sort_by { |key| -key.length }
+        end
+      end
     end
   end
 end

data/lib/llm_cost_tracker/railtie.rb

@@ -3,7 +3,15 @@
 module LlmCostTracker
   class Railtie < Rails::Railtie
     generators do
+      require_relative "generators/llm_cost_tracker/add_latency_ms_generator"
       require_relative "generators/llm_cost_tracker/install_generator"
+      require_relative "generators/llm_cost_tracker/prices_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_cost_precision_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_tags_to_jsonb_generator"
+    end
+
+    rake_tasks do
+      load File.expand_path("../tasks/llm_cost_tracker.rake", __dir__)
     end
 
     initializer "llm_cost_tracker.configure" do

data/lib/llm_cost_tracker/report.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "report_data"
+require_relative "report_formatter"
+
+module LlmCostTracker
+  class Report
+    DEFAULT_DAYS = ReportData::DEFAULT_DAYS
+
+    class << self
+      # Render a terminal-friendly cost report from ActiveRecord storage.
+      #
+      # @param days [Integer] Number of trailing days to include.
+      # @param now [Time] Report end time.
+      # @return [String]
+      def generate(days: DEFAULT_DAYS, now: Time.now.utc)
+        ReportFormatter.new(data(days: days, now: now)).to_s
+      rescue LoadError => e
+        "Unable to build LLM cost report: ActiveRecord storage is unavailable (#{e.message})"
+      rescue StandardError => e
+        "Unable to build LLM cost report: #{e.class}: #{e.message}"
+      end
+
+      def data(days: DEFAULT_DAYS, now: Time.now.utc)
+        ReportData.build(days: days, now: now)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/report_data.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "value_object"
+
+module LlmCostTracker
+  TopCall = ValueObject.define(:provider, :model, :total_cost)
+
+  ReportData = ValueObject.define(
+    :days,
+    :from_time,
+    :to_time,
+    :total_cost,
+    :requests_count,
+    :average_latency_ms,
+    :unknown_pricing_count,
+    :cost_by_provider,
+    :cost_by_model,
+    :cost_by_feature,
+    :top_calls
+  )
+
+  ReportData.const_set(:DEFAULT_DAYS, 30)
+  ReportData.const_set(:TOP_LIMIT, 5)
+
+  class << ReportData
+    def build(days: ReportData::DEFAULT_DAYS, now: Time.now.utc)
+      require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
+
+      days = normalized_days(days)
+      scope = LlmApiCall.where(tracked_at: from_time(days, now)..now)
+
+      new(
+        days: days,
+        from_time: from_time(days, now),
+        to_time: now,
+        total_cost: scope.sum(:total_cost).to_f,
+        requests_count: scope.count,
+        average_latency_ms: average_latency_ms(scope),
+        unknown_pricing_count: scope.where(total_cost: nil).count,
+        cost_by_provider: cost_by(scope, :provider),
+        cost_by_model: cost_by(scope, :model),
+        cost_by_feature: cost_by_feature(scope),
+        top_calls: top_calls(scope)
+      )
+    end
+
+    private
+
+    def normalized_days(days)
+      days = days.to_i
+      days.positive? ? days : ReportData::DEFAULT_DAYS
+    end
+
+    def from_time(days, now)
+      now - (days * 86_400)
+    end
+
+    def average_latency_ms(scope)
+      return nil unless LlmApiCall.latency_column?
+
+      scope.average(:latency_ms)&.to_f
+    end
+
+    def cost_by(scope, column)
+      scope.group(column).sum(:total_cost).transform_values(&:to_f).sort_by { |_name, cost| -cost }
+    end
+
+    def cost_by_feature(scope)
+      costs = Hash.new(0.0)
+      scope.select(:id, :tags, :total_cost).find_each do |call|
+        costs[call.feature || "(untagged)"] += call.total_cost.to_f
+      end
+      costs.sort_by { |_feature, cost| -cost }
+    end
+
+    def top_calls(scope)
+      scope
+        .where.not(total_cost: nil)
+        .order(total_cost: :desc)
+        .limit(ReportData::TOP_LIMIT)
+        .map { |call| TopCall.new(provider: call.provider, model: call.model, total_cost: call.total_cost.to_f) }
+    end
+  end
+end

data/lib/llm_cost_tracker/report_formatter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class ReportFormatter
+    TOP_LIMIT = 5
+
+    def initialize(data)
+      @data = data
+    end
+
+    def to_s
+      lines = ["LLM Cost Report (last #{@data.days} days)", ""]
+      append_summary(lines)
+      append_cost_section(lines, "By provider", @data.cost_by_provider)
+      append_cost_section(lines, "By model", @data.cost_by_model)
+      append_cost_section(lines, "By feature", @data.cost_by_feature)
+      append_top_calls(lines)
+      lines.join("\n")
+    end
+
+    private
+
+    def append_summary(lines)
+      lines << "Total cost: #{money(@data.total_cost)}"
+      lines << "Requests: #{@data.requests_count}"
+      lines << "Avg latency: #{average_latency}"
+      lines << "Unknown pricing: #{@data.unknown_pricing_count}"
+    end
+
+    def append_cost_section(lines, title, rows)
+      lines << ""
+      lines << "#{title}:"
+      return lines << "  none" if rows.empty?
+
+      rows.first(TOP_LIMIT).each do |name, cost|
+        lines << "  #{name.to_s.ljust(28)} #{money(cost)}"
+      end
+    end
+
+    def append_top_calls(lines)
+      lines << ""
+      lines << "Top expensive calls:"
+      return lines << "  none" if @data.top_calls.empty?
+
+      @data.top_calls.first(TOP_LIMIT).each do |call|
+        label = "#{call.provider}/#{call.model}"
+        lines << "  #{label.ljust(32)} #{money(call.total_cost)}"
+      end
+    end
+
+    def average_latency
+      @data.average_latency_ms ? "#{@data.average_latency_ms.round}ms" : "n/a"
+    end
+
+    def money(value)
+      "$#{format('%.6f', value.to_f)}"
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/active_record_backend.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Storage
+    module ActiveRecordBackend
+      class << self
+        def save(event, **_options)
+          require_relative "../llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
+          require_relative "active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
+
+          ActiveRecordStore.save(event)
+          event
+        rescue LoadError => e
+          raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -5,18 +5,23 @@ module LlmCostTracker
     class ActiveRecordStore
       class << self
         def save(event)
-          model_class.create!(
-            provider:      event[:provider],
-            model:         event[:model],
-            input_tokens:  event[:input_tokens],
-            output_tokens: event[:output_tokens],
-            total_tokens:  event[:total_tokens],
-            input_cost:    event.dig(:cost, :input_cost),
-            output_cost:   event.dig(:cost, :output_cost),
-            total_cost:    event.dig(:cost, :total_cost),
-            tags:          stringify_tags(event[:tags]).to_json,
-            tracked_at:    event[:tracked_at]
-          )
+          tags = stringify_tags(event.tags || {})
+
+          attributes = {
+            provider:      event.provider,
+            model:         event.model,
+            input_tokens:  event.input_tokens,
+            output_tokens: event.output_tokens,
+            total_tokens:  event.total_tokens,
+            input_cost:    event.cost&.input_cost,
+            output_cost:   event.cost&.output_cost,
+            total_cost:    event.cost&.total_cost,
+            tags:          tags_for_storage(tags),
+            tracked_at:    event.tracked_at
+          }
+          attributes[:latency_ms] = event.latency_ms if model_class.latency_column?
+
+          model_class.create!(attributes)
         end
 
         def monthly_total(time: Time.now.utc)
@@ -38,6 +43,10 @@ module LlmCostTracker
           tags.transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
         end
 
+        def tags_for_storage(tags)
+          model_class.tags_json_column? ? tags : tags.to_json
+        end
+
         def stringify_tag_value(value)
           return value.transform_values { |nested| stringify_tag_value(nested) } if value.is_a?(Hash)
 

data/lib/llm_cost_tracker/storage/backends.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "log_backend"
+require_relative "active_record_backend"
+require_relative "custom_backend"
+
+module LlmCostTracker
+  module Storage
+    module Backends
+      MAP = {
+        log: LogBackend,
+        active_record: ActiveRecordBackend,
+        custom: CustomBackend
+      }.freeze
+
+      class << self
+        def fetch(name)
+          MAP.fetch(name.to_sym)
+        rescue KeyError
+          raise Error, "Unknown storage_backend: #{name.inspect}. Use one of: #{MAP.keys.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/custom_backend.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Storage
+    module CustomBackend
+      class << self
+        def save(event, config:)
+          result = config.custom_storage&.call(event)
+          return false if result == false
+
+          event
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/log_backend.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../logging"
+
+module LlmCostTracker
+  module Storage
+    module LogBackend
+      class << self
+        def save(event, config:)
+          message = "#{event.provider}/#{event.model} " \
+                    "tokens=#{event.input_tokens}+#{event.output_tokens} " \
+                    "cost=#{cost_label(event)}"
+          message += " latency=#{event.latency_ms}ms" if event.latency_ms
+          message += " tags=#{event.tags}" unless event.tags.empty?
+
+          Logging.log(config.log_level, message)
+          event
+        end
+
+        private
+
+        def cost_label(event)
+          event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tag_accessors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LlmCostTracker
+  module TagAccessors
+    def parsed_tags
+      return tags.transform_keys(&:to_s) if tags.is_a?(Hash)
+
+      JSON.parse(tags || "{}")
+    rescue JSON::ParserError
+      {}
+    end
+
+    def feature
+      parsed_tags["feature"]
+    end
+
+    def user_id
+      parsed_tags["user_id"]
+    end
+  end
+end

data/lib/llm_cost_tracker/tag_query.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LlmCostTracker
+  module TagQuery
+    class << self
+      def apply(model, tags)
+        normalized_tags = normalize_tags(tags)
+        return model.all if normalized_tags.empty?
+
+        return json_query(model, normalized_tags) if model.tags_json_column?
+
+        text_query(model, normalized_tags)
+      end
+
+      def normalize_tags(tags)
+        (tags || {}).to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      end
+
+      private
+
+      def json_query(model, tags)
+        model.where("tags @> ?::jsonb", tags.to_json)
+      end
+
+      def text_query(model, tags)
+        tags.reduce(model.all) do |relation, (key, value)|
+          relation.where("tags LIKE ? ESCAPE '\\'", "%#{model.sanitize_sql_like(json_tag_fragment(key, value))}%")
+        end
+      end
+
+      def json_tag_fragment(key, value)
+        JSON.generate(key => value).delete_prefix("{").delete_suffix("}")
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tags_column.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module TagsColumn
+    def tags_json_column?
+      column = columns_hash["tags"]
+      return false unless column
+
+      %i[json jsonb].include?(column.type) || column.sql_type.to_s.downcase == "jsonb"
+    end
+
+    def latency_column?
+      columns_hash.key?("latency_ms")
+    end
+  end
+end