llm_cost_tracker 0.3.0 → 0.3.1

data/lib/llm_cost_tracker/price_registry.rb

@@ -26,9 +26,7 @@ module LlmCostTracker
       end
 
       def normalize_price_table(table)
-        (table || {}).each_with_object({}) do |(model, price), normalized|
-          normalized[model.to_s] = normalize_price_entry(price)
-        end
+        normalize_price_entries(table, context: "price table")
       end
 
       def file_prices(path)
@@ -47,7 +45,7 @@ module LlmCostTracker
           @file_prices_cache = { key: cache_key, value: value }.freeze
           value
         end
-      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError, NoMethodError => e
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
         raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
       end
 
@@ -60,15 +58,23 @@ module LlmCostTracker
       end
 
       def normalize_price_entry(price)
-        (price || {}).each_with_object({}) do |(key, value), normalized|
+        price.each_with_object({}) do |(key, value), normalized|
           key = key.to_s
           normalized[key.to_sym] = Float(value) if PRICE_KEYS.include?(key)
         end
       end
 
       def normalize_file_prices(table, path:)
-        (table || {}).each_with_object({}) do |(model, price), normalized|
-          warn_unknown_keys(model, price, path)
+        normalize_price_entries(table, context: path)
+      end
+
+      def normalize_price_entries(table, context:)
+        table = {} if table.nil?
+        raise ArgumentError, "#{context} must be a hash of models" unless table.is_a?(Hash)
+
+        table.each_with_object({}) do |(model, price), normalized|
+          price = validate_price_entry(price, model: model, context: context)
+          warn_unknown_keys(model, price, context)
           normalized[model.to_s] = normalize_price_entry(price)
         end
       end
@@ -95,8 +101,17 @@ module LlmCostTracker
       end
 
       def price_file_models(registry)
+        raise ArgumentError, "prices_file must be a hash" unless registry.is_a?(Hash)
+
         registry.fetch("models", registry)
       end
+
+      def validate_price_entry(price, model:, context:)
+        return {} if price.nil?
+        return price if price.is_a?(Hash)
+
+        raise ArgumentError, "price entry for #{model.inspect} in #{context} must be a hash"
+      end
     end
   end
 end

data/lib/llm_cost_tracker/price_sync/refresh_plan_builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module PriceSync
+    class RefreshPlanBuilder
+      def initialize(sources:, loader: RegistryLoader.new)
+        @sources = sources
+        @loader = loader
+      end
+
+      def call(path:, seed_path:, fetcher:, today:)
+        path = path.to_s
+        registry = loader.call(path: path, seed_path: seed_path)
+        current_models = registry.fetch("models", {})
+        source_results, failed_sources = fetch_all(current_models, fetcher)
+        merged, discrepancies = Merger.new.merge(source_results)
+        validated = Validator.new.validate_batch(merged, existing_registry: current_models)
+        updated_models = apply_changes(current_models, validated.accepted, today)
+
+        PriceSync::RefreshPlan.new(
+          path: path,
+          registry: registry,
+          updated_registry: registry.merge(
+            "metadata" => updated_metadata(
+              registry["metadata"],
+              today,
+              refresh_succeeded: source_results.any? { |_source, result| result.prices.any? },
+              source_results: source_results
+            ),
+            "models" => updated_models
+          ),
+          accepted: validated.accepted,
+          changes: price_changes(current_models, updated_models),
+          orphaned_models: compute_orphaned(current_models, merged.keys),
+          failed_sources: failed_sources,
+          discrepancies: discrepancies,
+          rejected: validated.rejected,
+          flagged: validated.flagged,
+          sources_used: source_usage(source_results),
+          source_results: source_results
+        )
+      end
+
+      private
+
+      attr_reader :sources, :loader
+
+      def fetch_all(current_models, fetcher)
+        results = {}
+        failures = {}
+
+        sources.each do |source|
+          results[source.name.to_sym] = source.fetch(current_models: current_models, fetcher: fetcher)
+        rescue Error => e
+          failures[source.name.to_sym] = e.message
+        end
+
+        [results, failures]
+      end
+
+      def apply_changes(current_models, accepted, today)
+        merged = seed_models(current_models)
+
+        accepted.each do |model, price|
+          next if manual_model?(merged[model])
+
+          merged[model] = registry_entry_for(merged[model], price, today)
+        end
+
+        merged.sort.to_h
+      end
+
+      def compute_orphaned(current_models, merged_models)
+        seed_models(current_models).keys.reject do |model|
+          manual_model?(current_models[model]) || merged_models.include?(model)
+        end.sort
+      end
+
+      def seed_models(current_models)
+        normalize_models(current_models).transform_values do |entry|
+          next entry if entry.key?("_source")
+
+          entry.merge("_source" => "seed")
+        end
+      end
+
+      def normalize_models(models)
+        normalize_hash(models).each_with_object({}) do |(model, entry), normalized|
+          normalized[model.to_s] = normalize_hash(entry)
+        end
+      end
+
+      def normalize_hash(hash)
+        return {} if hash.nil?
+        raise ArgumentError, "price sync entries must be hashes" unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), normalized|
+          normalized[key.to_s] = value
+        end
+      end
+
+      def manual_model?(entry)
+        normalize_hash(entry)["_source"] == "manual"
+      end
+
+      def registry_entry_for(existing_entry, price, today)
+        normalize_hash(existing_entry)
+          .except(*PriceRegistry::PRICE_KEYS)
+          .merge(price.to_registry_entry(today: today))
+      end
+
+      def updated_metadata(existing, today, refresh_succeeded:, source_results:)
+        metadata = normalize_hash(existing)
+        metadata["currency"] ||= "USD"
+        metadata["unit"] ||= "1M tokens"
+        return metadata unless refresh_succeeded
+
+        metadata["updated_at"] = today.iso8601
+        metadata["source_urls"] = source_urls(source_results)
+        metadata
+      end
+
+      def source_usage(source_results)
+        source_results.transform_values do |result|
+          PriceSync::SourceUsage.new(prices_count: result.prices.size, source_version: result.source_version)
+        end
+      end
+
+      def price_changes(current_models, updated_models)
+        current_models = normalize_models(current_models)
+        updated_models = normalize_models(updated_models)
+
+        (current_models.keys | updated_models.keys).sort.each_with_object({}) do |model, changes|
+          fields = price_field_changes(current_models[model], updated_models[model])
+          changes[model] = fields if fields.any?
+        end
+      end
+
+      def price_field_changes(current_entry, updated_entry)
+        current_price = comparable_price(current_entry)
+        updated_price = comparable_price(updated_entry)
+
+        (current_price.keys | updated_price.keys).sort.each_with_object({}) do |field, changes|
+          from = current_price[field]
+          to = updated_price[field]
+          next if from == to
+
+          changes[field] = { "from" => from, "to" => to }
+        end
+      end
+
+      def comparable_price(entry)
+        normalize_hash(entry).slice(*PriceRegistry::PRICE_KEYS)
+      end
+
+      def source_urls(source_results)
+        names = source_results.keys.map(&:to_sym)
+        sources.select { |source| names.include?(source.name.to_sym) }.map(&:url)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_sync/registry_loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module LlmCostTracker
+  module PriceSync
+    class RegistryLoader
+      YAML_EXTENSIONS = %w[.yml .yaml].freeze
+
+      def call(path:, seed_path:)
+        source_path = File.exist?(path.to_s) ? path.to_s : seed_path.to_s
+        normalize_registry(load_registry_file(source_path))
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+        raise Error, "Unable to load pricing registry #{source_path.inspect}: #{e.message}"
+      end
+
+      private
+
+      def load_registry_file(path)
+        contents = File.read(path)
+        registry = yaml_file?(path) ? (YAML.safe_load(contents, aliases: false) || {}) : JSON.parse(contents)
+        raise ArgumentError, "pricing registry must be a hash" unless registry.is_a?(Hash)
+
+        registry
+      end
+
+      def normalize_registry(registry)
+        {
+          "metadata" => normalize_hash(registry.fetch("metadata", {}), label: "pricing metadata"),
+          "models" => normalize_models(registry.fetch("models", {}))
+        }
+      end
+
+      def normalize_models(models)
+        normalize_hash(models, label: "pricing models").each_with_object({}) do |(model, entry), normalized|
+          normalized[model.to_s] = normalize_hash(entry, label: "pricing model entry")
+        end
+      end
+
+      def normalize_hash(hash, label:)
+        return {} if hash.nil?
+        raise ArgumentError, "#{label} must be a hash" unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), normalized|
+          normalized[key.to_s] = value
+        end
+      end
+
+      def yaml_file?(path)
+        YAML_EXTENSIONS.include?(File.extname(path).downcase)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_sync/registry_writer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "yaml"
+
+module LlmCostTracker
+  module PriceSync
+    class RegistryWriter
+      YAML_EXTENSIONS = %w[.yml .yaml].freeze
+
+      def call(path:, registry:)
+        FileUtils.mkdir_p(File.dirname(path))
+        payload = yaml_file?(path) ? YAML.dump(registry) : "#{JSON.pretty_generate(registry)}\n"
+        File.write(path, payload)
+      end
+
+      private
+
+      def yaml_file?(path)
+        YAML_EXTENSIONS.include?(File.extname(path).downcase)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_sync.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "date"
-require "fileutils"
-require "json"
-require "yaml"
 
 require_relative "price_sync/fetcher"
 require_relative "price_sync/raw_price"
 require_relative "price_sync/source"
 require_relative "price_sync/source_result"
+require_relative "price_sync/registry_loader"
+require_relative "price_sync/registry_writer"
+require_relative "price_sync/refresh_plan_builder"
 require_relative "price_sync/model_catalog"
 require_relative "price_sync/merger"
 require_relative "price_sync/validator"
@@ -16,10 +16,8 @@ require_relative "price_sync/sources/litellm"
 require_relative "price_sync/sources/open_router"
 
 module LlmCostTracker
-  # rubocop:disable Metrics/ModuleLength, Metrics/ClassLength
   module PriceSync
     DEFAULT_OUTPUT_PATH = PriceRegistry::DEFAULT_PRICES_PATH
-    YAML_EXTENSIONS = %w[.yml .yaml].freeze
 
     SourceUsage = Data.define(:prices_count, :source_version)
     SyncResult = Data.define(
@@ -71,11 +69,16 @@ module LlmCostTracker
     class << self
       def sync(path: DEFAULT_OUTPUT_PATH, seed_path: DEFAULT_OUTPUT_PATH, preview: false, strict: false,
                fetcher: Fetcher.new, today: Date.today)
-        plan = build_refresh_plan(path: path, seed_path: seed_path, fetcher: fetcher, today: today)
+        plan = RefreshPlanBuilder.new(sources: sources).call(
+          path: path,
+          seed_path: seed_path,
+          fetcher: fetcher,
+          today: today
+        )
         raise Error, strict_failure_message(plan) if strict_sync_failure?(plan, strict: strict)
 
         written = !preview && plan.refresh_succeeded?
-        write_registry(plan.path, plan.updated_registry) if written
+        RegistryWriter.new.call(path: plan.path, registry: plan.updated_registry) if written
 
         SyncResult.new(
           path: plan.path,
@@ -92,7 +95,12 @@ module LlmCostTracker
       end
 
       def check(path: DEFAULT_OUTPUT_PATH, seed_path: DEFAULT_OUTPUT_PATH, fetcher: Fetcher.new, today: Date.today)
-        plan = build_refresh_plan(path: path, seed_path: seed_path, fetcher: fetcher, today: today)
+        plan = RefreshPlanBuilder.new(sources: sources).call(
+          path: path,
+          seed_path: seed_path,
+          fetcher: fetcher,
+          today: today
+        )
 
         CheckResult.new(
           path: plan.path,
@@ -113,166 +121,6 @@ module LlmCostTracker
         [Sources::Litellm.new, Sources::OpenRouter.new]
       end
 
-      def build_refresh_plan(path:, seed_path:, fetcher:, today:)
-        path = path.to_s
-        registry = load_registry(path, seed_path: seed_path)
-        current_models = registry.fetch("models", {})
-        source_results, failed_sources = fetch_all(current_models, fetcher)
-        merged, discrepancies = Merger.new.merge(source_results)
-        validated = Validator.new.validate_batch(merged, existing_registry: current_models)
-        updated_models = apply_changes(current_models, validated.accepted, today)
-        refresh_succeeded = source_results.any? { |_source, result| result.prices.any? }
-
-        RefreshPlan.new(
-          path: path,
-          registry: registry,
-          updated_registry: registry.merge(
-            "metadata" => updated_metadata(
-              registry["metadata"],
-              today,
-              refresh_succeeded: refresh_succeeded,
-              source_results: source_results
-            ),
-            "models" => updated_models
-          ),
-          accepted: validated.accepted,
-          changes: price_changes(current_models, updated_models),
-          orphaned_models: compute_orphaned(current_models, merged.keys),
-          failed_sources: failed_sources,
-          discrepancies: discrepancies,
-          rejected: validated.rejected,
-          flagged: validated.flagged,
-          sources_used: source_usage(source_results),
-          source_results: source_results
-        )
-      end
-
-      def fetch_all(current_models, fetcher)
-        results = {}
-        failures = {}
-
-        sources.each do |source|
-          results[source.name.to_sym] = source.fetch(current_models: current_models, fetcher: fetcher)
-        rescue Error => e
-          failures[source.name.to_sym] = e.message
-        end
-
-        [results, failures]
-      end
-
-      def apply_changes(current_models, accepted, today)
-        merged = seed_models(current_models)
-
-        accepted.each do |model, price|
-          next if manual_model?(merged[model])
-
-          merged[model] = registry_entry_for(merged[model], price, today)
-        end
-
-        merged.sort.to_h
-      end
-
-      def compute_orphaned(current_models, merged_models)
-        seed_models(current_models).keys.reject do |model|
-          manual_model?(current_models[model]) || merged_models.include?(model)
-        end.sort
-      end
-
-      def load_registry(path, seed_path:)
-        source_path = File.exist?(path) ? path : seed_path.to_s
-        normalize_registry(load_registry_file(source_path))
-      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError, NoMethodError => e
-        raise Error, "Unable to load pricing registry #{source_path.inspect}: #{e.message}"
-      end
-
-      def load_registry_file(path)
-        contents = File.read(path)
-        return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)
-
-        JSON.parse(contents)
-      end
-
-      def normalize_registry(registry)
-        {
-          "metadata" => normalize_hash(registry.fetch("metadata", {})),
-          "models" => normalize_models(registry.fetch("models", {}))
-        }
-      end
-
-      def normalize_models(models)
-        (models || {}).each_with_object({}) do |(model, entry), normalized|
-          normalized[model.to_s] = normalize_hash(entry)
-        end
-      end
-
-      def normalize_hash(hash)
-        (hash || {}).each_with_object({}) do |(key, value), normalized|
-          normalized[key.to_s] = value
-        end
-      end
-
-      def seed_models(current_models)
-        normalize_models(current_models).transform_values do |entry|
-          next entry if entry.key?("_source")
-
-          entry.merge("_source" => "seed")
-        end
-      end
-
-      def manual_model?(entry)
-        normalize_hash(entry)["_source"] == "manual"
-      end
-
-      def registry_entry_for(existing_entry, price, today)
-        normalize_hash(existing_entry)
-          .except(*PriceRegistry::PRICE_KEYS)
-          .merge(price.to_registry_entry(today: today))
-      end
-
-      def updated_metadata(existing, today, refresh_succeeded:, source_results:)
-        metadata = normalize_hash(existing)
-        metadata["currency"] ||= "USD"
-        metadata["unit"] ||= "1M tokens"
-        return metadata unless refresh_succeeded
-
-        metadata["updated_at"] = today.iso8601
-        metadata["source_urls"] = source_urls(source_results)
-        metadata
-      end
-
-      def source_usage(source_results)
-        source_results.transform_values do |result|
-          SourceUsage.new(prices_count: result.prices.size, source_version: result.source_version)
-        end
-      end
-
-      def price_changes(current_models, updated_models)
-        current_models = normalize_models(current_models)
-        updated_models = normalize_models(updated_models)
-
-        (current_models.keys | updated_models.keys).sort.each_with_object({}) do |model, changes|
-          fields = price_field_changes(current_models[model], updated_models[model])
-          changes[model] = fields if fields.any?
-        end
-      end
-
-      def price_field_changes(current_entry, updated_entry)
-        current_price = comparable_price(current_entry)
-        updated_price = comparable_price(updated_entry)
-
-        (current_price.keys | updated_price.keys).sort.each_with_object({}) do |field, changes|
-          from = current_price[field]
-          to = updated_price[field]
-          next if from == to
-
-          changes[field] = { "from" => from, "to" => to }
-        end
-      end
-
-      def comparable_price(entry)
-        normalize_hash(entry).slice(*PriceRegistry::PRICE_KEYS)
-      end
-
       def strict_sync_failure?(plan, strict:)
         strict && (plan.failed_sources.any? || plan.rejected.any?)
       end
@@ -289,22 +137,6 @@ module LlmCostTracker
         end
         "Price sync failed in strict mode: #{messages.join('; ')}"
       end
-
-      def source_urls(source_results)
-        names = source_results.keys.map(&:to_sym)
-        sources.select { |source| names.include?(source.name.to_sym) }.map(&:url)
-      end
-
-      def write_registry(path, registry)
-        FileUtils.mkdir_p(File.dirname(path))
-        payload = yaml_file?(path) ? YAML.dump(registry) : "#{JSON.pretty_generate(registry)}\n"
-        File.write(path, payload)
-      end
-
-      def yaml_file?(path)
-        YAML_EXTENSIONS.include?(File.extname(path).downcase)
-      end
     end
   end
-  # rubocop:enable Metrics/ModuleLength, Metrics/ClassLength
 end

data/lib/llm_cost_tracker/pricing.rb

@@ -3,21 +3,11 @@
 require "monitor"
 
 module LlmCostTracker
-  # Calculates costs from price entries expressed in USD per 1M tokens.
   module Pricing
     PRICES = PriceRegistry.builtin_prices
     MUTEX = Monitor.new
 
     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)
@@ -111,7 +101,6 @@ module LlmCostTracker
         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)

data/lib/llm_cost_tracker/railtie.rb

@@ -15,7 +15,6 @@ module LlmCostTracker
     end
 
     initializer "llm_cost_tracker.configure" do
-      # Auto-require ActiveRecord storage if configured
       ActiveSupport.on_load(:active_record) do
         if LlmCostTracker.configuration.active_record?
           require_relative "llm_api_call"

data/lib/llm_cost_tracker/report.rb

@@ -8,11 +8,6 @@ module LlmCostTracker
     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, tag_breakdowns: nil)
         ReportFormatter.new(data(days: days, now: now, tag_breakdowns: tag_breakdowns)).to_s
       rescue LoadError => e

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -19,24 +19,23 @@ module LlmCostTracker
             tags:          tags_for_storage(tags),
             tracked_at:    event.tracked_at
           }
-          attributes[:latency_ms]   = event.latency_ms   if model_class.latency_column?
-          attributes[:stream]       = event.stream       if model_class.stream_column?
-          attributes[:usage_source] = event.usage_source if model_class.usage_source_column?
-
-          model_class.create!(attributes)
+          attributes[:latency_ms] = event.latency_ms if LlmCostTracker::LlmApiCall.latency_column?
+          attributes[:stream] = event.stream if LlmCostTracker::LlmApiCall.stream_column?
+          attributes[:usage_source] = event.usage_source if LlmCostTracker::LlmApiCall.usage_source_column?
+          if LlmCostTracker::LlmApiCall.provider_response_id_column?
+            attributes[:provider_response_id] = event.provider_response_id
+          end
+
+          LlmCostTracker::LlmApiCall.create!(attributes)
         end
 
         def monthly_total(time: Time.now.utc)
-          model_class
+          LlmCostTracker::LlmApiCall
             .where(tracked_at: time.beginning_of_month..time)
             .sum(:total_cost)
             .to_f
         end
 
-        def model_class
-          LlmCostTracker::LlmApiCall
-        end
-
         private
 
         def stringify_tags(tags)
@@ -44,7 +43,7 @@ module LlmCostTracker
         end
 
         def tags_for_storage(tags)
-          model_class.tags_json_column? ? tags : tags.to_json
+          LlmCostTracker::LlmApiCall.tags_json_column? ? tags : tags.to_json
         end
 
         def stringify_tag_value(value)