llm_cost_tracker 0.1.2 → 0.1.3

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -3,6 +3,8 @@
 require "faraday"
 require "json"
 
+require_relative "../logging"
+
 module LlmCostTracker
   module Middleware
     class Faraday < ::Faraday::Middleware
@@ -21,13 +23,13 @@ module LlmCostTracker
         started_at = monotonic_time
 
         @app.call(request_env).on_complete do |response_env|
-          process(request_url, request_body, response_env, elapsed_ms(started_at))
+          process(request_env, request_url, request_body, response_env, elapsed_ms(started_at))
         end
       end
 
       private
 
-      def process(request_url, request_body, response_env, latency_ms)
+      def process(request_env, request_url, request_body, response_env, latency_ms)
         parser = Parsers::Registry.find_for(request_url)
         return unless parser
 
@@ -40,18 +42,18 @@ module LlmCostTracker
           input_tokens: parsed[:input_tokens],
           output_tokens: parsed[:output_tokens],
           latency_ms: latency_ms,
-          metadata: @tags.merge(parsed.except(:provider, :model, :input_tokens, :output_tokens, :total_tokens))
+          metadata: resolved_tags(request_env).merge(parsed.metadata)
         )
       rescue LlmCostTracker::Error
         raise
       rescue StandardError => e
-        log_warning("Error processing response: #{e.class}: #{e.message}")
+        Logging.warn("Error processing response: #{e.class}: #{e.message}")
       end
 
       def parse_response(parser, request_url, request_body, response_env)
         response_body = read_body(response_env.body)
         unless response_body
-          log_warning(
+          Logging.warn(
             "Unable to read response body for #{request_url}; streaming/SSE responses require manual tracking."
           )
           return nil
@@ -76,14 +78,15 @@ module LlmCostTracker
         end
       end
 
-      def log_warning(message)
-        message = "[LlmCostTracker] #{message}"
+      def resolved_tags(request_env)
+        tags = @tags.respond_to?(:call) ? call_tags(request_env) : @tags
+        return {} if tags.nil?
 
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.warn(message)
-        else
-          warn message
-        end
+        tags.to_h
+      end
+
+      def call_tags(request_env)
+        @tags.arity.zero? ? @tags.call : @tags.call(request_env)
       end
 
       def monotonic_time

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "value_object"
+
+module LlmCostTracker
+  ParsedUsage = ValueObject.define(
+    :provider,
+    :model,
+    :input_tokens,
+    :output_tokens,
+    :total_tokens,
+    :cached_input_tokens,
+    :cache_read_input_tokens,
+    :cache_creation_input_tokens,
+    :reasoning_tokens
+  )
+
+  ParsedUsage.const_set(:TRACKING_KEYS, %i[provider model input_tokens output_tokens total_tokens].freeze)
+
+  class << ParsedUsage
+    def build(**attributes)
+      new(
+        provider: attributes.fetch(:provider),
+        model: attributes.fetch(:model),
+        input_tokens: attributes.fetch(:input_tokens).to_i,
+        output_tokens: attributes.fetch(:output_tokens).to_i,
+        total_tokens: attributes.fetch(:total_tokens, 0).to_i,
+        cached_input_tokens: attributes[:cached_input_tokens],
+        cache_read_input_tokens: attributes[:cache_read_input_tokens],
+        cache_creation_input_tokens: attributes[:cache_creation_input_tokens],
+        reasoning_tokens: attributes[:reasoning_tokens]
+      )
+    end
+  end
+
+  class ParsedUsage
+    def metadata
+      except(*TRACKING_KEYS)
+    end
+
+    def to_h
+      super.compact
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require "uri"
 
 require_relative "base"
@@ -26,7 +25,7 @@ module LlmCostTracker
 
         request = safe_json_parse(request_body)
 
-        {
+        ParsedUsage.build(
           provider: "anthropic",
           model: response["model"] || request["model"],
           input_tokens: usage["input_tokens"] || 0,
@@ -36,7 +35,7 @@ module LlmCostTracker
             (usage["cache_creation_input_tokens"] || 0),
           cache_read_input_tokens: usage["cache_read_input_tokens"],
           cache_creation_input_tokens: usage["cache_creation_input_tokens"]
-        }.compact
+        )
       end
     end
   end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module LlmCostTracker
   module Parsers
     class Base

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require "uri"
 
 require_relative "base"
@@ -9,10 +8,11 @@ module LlmCostTracker
   module Parsers
     class Gemini < Base
       HOSTS = %w[generativelanguage.googleapis.com].freeze
+      TRACKED_PATH_PATTERN = %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}
 
       def match?(url)
         uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host.to_s.downcase)
+        HOSTS.include?(uri.host.to_s.downcase) && uri.path.match?(TRACKED_PATH_PATTERN)
       rescue URI::InvalidURIError
         false
       end
@@ -27,14 +27,14 @@ module LlmCostTracker
         # Extract model from URL: /v1beta/models/gemini-2.5-flash:generateContent
         model = extract_model_from_url(request_url)
 
-        {
+        ParsedUsage.build(
           provider: "gemini",
           model: model,
           input_tokens: usage["promptTokenCount"] || 0,
           output_tokens: output_tokens(usage),
           total_tokens: usage["totalTokenCount"] || 0,
           cached_input_tokens: usage["cachedContentTokenCount"]
-        }.compact
+        )
       end
 
       private

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-require "json"
 require "uri"
 
 require_relative "base"
+require_relative "openai_usage"
 
 module LlmCostTracker
   module Parsers
     class Openai < Base
+      include OpenaiUsage
+
       HOSTS = %w[api.openai.com].freeze
       TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
 
@@ -19,22 +21,7 @@ module LlmCostTracker
       end
 
       def parse(request_url, request_body, response_status, response_body)
-        return nil unless response_status == 200
-
-        response = safe_json_parse(response_body)
-        usage    = response["usage"]
-        return nil unless usage
-
-        request = safe_json_parse(request_body)
-
-        {
-          provider: provider_for(request_url),
-          model: response["model"] || request["model"],
-          input_tokens: usage["prompt_tokens"] || usage["input_tokens"] || 0,
-          output_tokens: usage["completion_tokens"] || usage["output_tokens"] || 0,
-          total_tokens: usage["total_tokens"] || 0,
-          cached_input_tokens: cached_input_tokens(usage)
-        }.compact
+        parse_openai_usage(request_url, request_body, response_status, response_body)
       end
 
       private
@@ -42,11 +29,6 @@ module LlmCostTracker
       def provider_for(_request_url)
         "openai"
       end
-
-      def cached_input_tokens(usage)
-        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
-        details["cached_tokens"]
-      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "openai"
+require "uri"
+
+require_relative "base"
+require_relative "openai_usage"
 
 module LlmCostTracker
   module Parsers
-    class OpenaiCompatible < Openai
+    class OpenaiCompatible < Base
+      include OpenaiUsage
+
       TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
 
       def match?(url)
@@ -14,6 +19,10 @@ module LlmCostTracker
         false
       end
 
+      def parse(request_url, request_body, response_status, response_body)
+        parse_openai_usage(request_url, request_body, response_status, response_body)
+      end
+
       private
 
       def provider_for(request_url)
@@ -24,12 +33,7 @@ module LlmCostTracker
       end
 
       def provider_for_host(host)
-        host = host.to_s.downcase
-        provider_name = configured_providers[host] ||
-                        configured_providers.find do |configured_host, _provider|
-                          configured_host.to_s.downcase == host
-                        end&.last
-        provider_name&.to_s
+        configured_providers[host.to_s.downcase]&.to_s
       end
 
       def configured_providers

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Parsers
+    module OpenaiUsage
+      private
+
+      def parse_openai_usage(request_url, request_body, response_status, response_body)
+        return nil unless response_status == 200
+
+        response = safe_json_parse(response_body)
+        usage = response["usage"]
+        return nil unless usage
+
+        request = safe_json_parse(request_body)
+
+        ParsedUsage.build(
+          provider: provider_for(request_url),
+          model: response["model"] || request["model"],
+          input_tokens: usage["prompt_tokens"] || usage["input_tokens"] || 0,
+          output_tokens: usage["completion_tokens"] || usage["output_tokens"] || 0,
+          total_tokens: usage["total_tokens"] || 0,
+          cached_input_tokens: cached_input_tokens(usage)
+        )
+      end
+
+      def cached_input_tokens(usage)
+        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
+        details["cached_tokens"]
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_registry.rb

@@ -3,10 +3,15 @@
 require "json"
 require "yaml"
 
+require_relative "logging"
+
 module LlmCostTracker
   module PriceRegistry
     DEFAULT_PRICES_PATH = File.expand_path("prices.json", __dir__)
+    EMPTY_PRICES = {}.freeze
     PRICE_KEYS = %w[input cached_input output cache_read_input cache_creation_input].freeze
+    METADATA_KEYS = %w[_source _updated _notes].freeze
+    FILE_PRICES_MUTEX = Mutex.new
     NORMALIZE_PRICE_ENTRY = lambda do |price|
       (price || {}).each_with_object({}) do |(key, value), normalized|
         key = key.to_s
@@ -22,6 +27,8 @@ module LlmCostTracker
     PRICE_METADATA = RAW_REGISTRY.fetch("metadata", {}).freeze
     BUILTIN_PRICES = NORMALIZE_PRICE_TABLE.call(RAW_REGISTRY.fetch("models", {})).freeze
 
+    private_constant :FILE_PRICES_MUTEX
+
     class << self
       def builtin_prices
         BUILTIN_PRICES
@@ -36,20 +43,43 @@ module LlmCostTracker
       end
 
       def file_prices(path)
-        return {} unless path
+        return EMPTY_PRICES unless path
 
         path = path.to_s
-        cache_key = [path, File.mtime(path).to_f]
-        return @file_prices if @file_prices_cache_key == cache_key
+        FILE_PRICES_MUTEX.synchronize do
+          cache_key = [path, File.mtime(path).to_f]
+          return @file_prices if @file_prices_cache_key == cache_key
 
-        @file_prices_cache_key = cache_key
-        @file_prices = normalize_price_table(price_file_models(load_price_file(path)))
-      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+          @file_prices_cache_key = cache_key
+          @file_prices = normalize_file_prices(price_file_models(load_price_file(path)), path: path).freeze
+        end
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError, NoMethodError => e
         raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
       end
 
       private
 
+      def normalize_file_prices(table, path:)
+        (table || {}).each_with_object({}) do |(model, price), normalized|
+          warn_unknown_keys(model, price, path)
+          normalized[model.to_s] = normalize_price_entry(price)
+        end
+      end
+
+      def normalize_price_entry(price)
+        NORMALIZE_PRICE_ENTRY.call(price)
+      end
+
+      def warn_unknown_keys(model, price, path)
+        unknown_keys = price.keys.map(&:to_s) - PRICE_KEYS - METADATA_KEYS
+        return if unknown_keys.empty?
+
+        Logging.warn(
+          "Unknown price keys #{unknown_keys.inspect} for #{model.inspect} in #{path}; " \
+          "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}"
+        )
+      end
+
       def load_price_file(path)
         contents = File.read(path)
         return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)

data/lib/llm_cost_tracker/pricing.rb

@@ -1,11 +1,25 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  # Prices per 1M tokens in USD.
+  # Calculates costs from price entries expressed in USD per 1M tokens.
   module Pricing
     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)
@@ -15,7 +29,7 @@ module LlmCostTracker
                                                cache_read_input_tokens, cache_creation_input_tokens)
         costs = calculate_costs(token_counts, prices)
 
-        {
+        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),
@@ -23,7 +37,7 @@ module LlmCostTracker
           output_cost: costs[:output].round(8),
           total_cost: costs.values.sum.round(8),
           currency: "USD"
-        }
+        )
       end
 
       def lookup(model)
@@ -43,9 +57,18 @@ module LlmCostTracker
       end
 
       def prices
-        PRICES
-          .merge(PriceRegistry.file_prices(LlmCostTracker.configuration.prices_file))
-          .merge(PriceRegistry.normalize_price_table(LlmCostTracker.configuration.pricing_overrides))
+        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
@@ -97,11 +120,14 @@ module LlmCostTracker
       end
 
       def sorted_price_keys(table)
-        cache_key = table.keys
-        return @sorted_price_keys if @sorted_price_keys_cache_key == cache_key
+        return @sorted_price_keys if @sorted_price_keys_table.equal?(table)
 
-        @sorted_price_keys_cache_key = cache_key
-        @sorted_price_keys = cache_key.sort_by { |key| -key.length }
+        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

data/lib/llm_cost_tracker/railtie.rb

@@ -5,10 +5,15 @@ module LlmCostTracker
     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
       # Auto-require ActiveRecord storage if configured
       ActiveSupport.on_load(:active_record) 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