llm_cost_tracker 0.7.0 → 0.7.1

data/lib/llm_cost_tracker/pricing/sync/registry_writer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "yaml"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      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"
+          temp_path = "#{path}.tmp-#{Process.pid}-#{Thread.current.object_id}"
+          File.write(temp_path, payload)
+          File.rename(temp_path, path)
+        ensure
+          FileUtils.rm_f(temp_path) if temp_path && File.exist?(temp_path)
+        end
+
+        private
+
+        def yaml_file?(path)
+          YAML_EXTENSIONS.include?(File.extname(path).downcase)
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "date"
+require "json"
+require "rubygems"
+
+require_relative "registry"
+require_relative "sync/fetcher"
+require_relative "sync/registry_diff"
+require_relative "sync/registry_loader"
+require_relative "sync/registry_writer"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      DEFAULT_OUTPUT_PATH = "config/llm_cost_tracker_prices.yml"
+      DEFAULT_REMOTE_URL =
+        "https://raw.githubusercontent.com/sergey-homenko/llm_cost_tracker/main/lib/llm_cost_tracker/prices.json"
+      SUPPORTED_SCHEMA_VERSION = 1
+
+      RefreshResult = Data.define(:path, :source_url, :source_version, :changes, :written, :not_modified)
+      CheckResult = Data.define(:path, :source_url, :source_version, :changes, :up_to_date)
+
+      class << self
+        def configured_output_path(env: ENV, config: LlmCostTracker.configuration)
+          output = env["OUTPUT"].to_s.strip.presence
+          return output if output
+
+          prices_file = config.prices_file
+          return prices_file.to_s if prices_file
+
+          default_output_path
+        end
+
+        def configured_remote_url(env: ENV)
+          env["URL"].to_s.strip.presence || DEFAULT_REMOTE_URL
+        end
+
+        def refresh(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, preview: false, fetcher: Fetcher.new,
+                    today: Date.today)
+          current = RegistryLoader.new.call(path: path, seed_path: Registry::DEFAULT_PRICES_PATH)
+          response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
+
+          if response.not_modified
+            return refresh_result(path, url, response, current, current, written: false, not_modified: true)
+          end
+
+          remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+          RegistryWriter.new.call(path: path, registry: remote) unless preview
+          refresh_result(path, url, response, current, remote, written: !preview, not_modified: false)
+        end
+
+        def check(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, fetcher: Fetcher.new, today: Date.today)
+          current = RegistryLoader.new.call(path: path, seed_path: Registry::DEFAULT_PRICES_PATH)
+          response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
+
+          if response.not_modified
+            return CheckResult.new(
+              path: path,
+              source_url: url,
+              source_version: response.source_version,
+              changes: {},
+              up_to_date: true
+            )
+          end
+
+          remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+          changes = RegistryDiff.call(current.fetch("models", {}), remote.fetch("models", {}))
+
+          CheckResult.new(
+            path: path,
+            source_url: url,
+            source_version: response.source_version,
+            changes: changes,
+            up_to_date: changes.empty?
+          )
+        end
+
+        private
+
+        def default_output_path
+          if Rails.root
+            Rails.root.join(DEFAULT_OUTPUT_PATH).to_s
+          else
+            DEFAULT_OUTPUT_PATH
+          end
+        end
+
+        def normalize_remote_registry(body, url:, response:, today:)
+          registry = parse_registry(body)
+          metadata = registry.fetch("metadata", {})
+          raise Error, "remote pricing metadata must be a hash" unless metadata.is_a?(Hash)
+
+          schema_version = Integer(metadata.fetch("schema_version", 1))
+          if schema_version > SUPPORTED_SCHEMA_VERSION
+            raise Error, "remote pricing schema_version=#{schema_version} requires a newer llm_cost_tracker"
+          end
+
+          min_gem_version = metadata["min_gem_version"]
+          if min_gem_version && Gem::Version.new(min_gem_version) > Gem::Version.new(LlmCostTracker::VERSION)
+            raise Error, "remote pricing snapshot requires llm_cost_tracker >= #{min_gem_version}"
+          end
+
+          models = registry.fetch("models", {})
+          Registry.normalize_price_table(models)
+
+          registry.merge(
+            "metadata" => metadata.merge(
+              "schema_version" => schema_version,
+              "updated_at" => metadata["updated_at"] || today.iso8601,
+              "source_url" => url,
+              "source_version" => response.source_version
+            ),
+            "models" => models
+          )
+        rescue ArgumentError, TypeError => e
+          raise Error, "Unable to load remote pricing snapshot: #{e.message}"
+        end
+
+        def parse_registry(body)
+          registry = JSON.parse(body.to_s)
+          raise Error, "remote pricing snapshot must be a JSON object" unless registry.is_a?(Hash)
+
+          registry
+        rescue JSON::ParserError => e
+          raise Error, "Unable to parse remote pricing snapshot: #{e.message}"
+        end
+
+        def refresh_result(path, url, response, current, remote, written:, not_modified:)
+          RefreshResult.new(
+            path: path,
+            source_url: url,
+            source_version: response.source_version,
+            changes: RegistryDiff.call(current.fetch("models", {}), remote.fetch("models", {})),
+            written: written,
+            not_modified: not_modified
+          )
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../logging"
+
+module LlmCostTracker
+  module Pricing
+    class Unknown
+      MUTEX = Mutex.new
+
+      class << self
+        def handle!(model)
+          model = model.to_s.presence || "unknown"
+
+          case LlmCostTracker.configuration.unknown_pricing_behavior
+          when :ignore
+            nil
+          when :warn
+            warn_missing(model)
+          when :raise
+            raise UnknownPricingError.new(model: model)
+          end
+        end
+
+        def reset!
+          MUTEX.synchronize { @warned_models = Set.new }
+        end
+
+        private
+
+        def warn_missing(model)
+          should_warn = MUTEX.synchronize do
+            @warned_models ||= Set.new
+            @warned_models.add?(model)
+          end
+          return unless should_warn
+
+          Logging.warn(
+            "No pricing configured for model #{model.inspect}. " \
+            "Cost and budget guardrails will be skipped for this event. " \
+            "Add a pricing_overrides entry or set unknown_pricing_behavior."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing.rb

@@ -1,67 +1,68 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/object/blank"
+
+require_relative "pricing/components"
+require_relative "pricing/registry"
 require_relative "pricing/lookup"
 require_relative "pricing/effective_prices"
 require_relative "pricing/explainer"
 
 module LlmCostTracker
   module Pricing
-    PRICES = PriceRegistry.builtin_prices
+    STANDARD_MODE_VALUES = %w[auto default standard standard_only].freeze
+    private_constant :STANDARD_MODE_VALUES
 
     class << self
-      def cost_for(provider:, model:, input_tokens:, output_tokens:, cache_read_input_tokens: 0,
-                   cache_write_input_tokens: 0, pricing_mode: nil)
+      def normalize_mode(value)
+        mode = value.to_s.strip.presence
+        return nil unless mode
+
+        mode = mode.tr("-", "_")
+        STANDARD_MODE_VALUES.include?(mode) ? nil : mode
+      end
+
+      def cost_for(provider:, model:, token_usage:, pricing_mode: nil)
         prices = lookup(provider: provider, model: model)
         return nil unless prices
 
-        usage = UsageBreakdown.build(
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          cache_read_input_tokens: cache_read_input_tokens,
-          cache_write_input_tokens: cache_write_input_tokens
-        )
-        costs = calculate_costs(usage, prices, pricing_mode: pricing_mode)
+        costs = calculate_costs(token_usage, prices, pricing_mode: pricing_mode)
         return nil unless costs
 
-        Cost.new(
-          input_cost: costs[:input].round(8),
-          cache_read_input_cost: costs[:cache_read_input].round(8),
-          cache_write_input_cost: costs[:cache_write_input].round(8),
-          output_cost: costs[:output].round(8),
-          total_cost: costs.values.sum.round(8),
-          currency: "USD"
-        )
+        values = COMPONENTS.to_h do |component|
+          [component.cost_key, costs.fetch(component.price_key).round(8)]
+        end
+
+        values.merge(total_cost: costs.values.sum.round(8))
       end
 
       def lookup(provider:, model:)
         Lookup.call(provider: provider, model: model)&.prices
       end
 
-      def explain(provider:, model:, input_tokens: 1, output_tokens: 1, cache_read_input_tokens: 0,
-                  cache_write_input_tokens: 0, pricing_mode: nil)
+      def explain(provider:, model:, token_usage:, pricing_mode: nil)
         Explainer.call(
           provider: provider,
           model: model,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          cache_read_input_tokens: cache_read_input_tokens,
-          cache_write_input_tokens: cache_write_input_tokens,
+          token_usage: token_usage,
           pricing_mode: pricing_mode
         )
       end
 
+      def stored_cost_attributes(attributes)
+        attributes.to_h.symbolize_keys.slice(*COST_KEYS).compact
+      end
+
       private
 
       def calculate_costs(usage, prices, pricing_mode:)
         effective = EffectivePrices.call(usage: usage, prices: prices, pricing_mode: pricing_mode)
-        return nil unless effective.complete?
-
-        {
-          input: token_cost(usage.input_tokens, effective.input),
-          cache_read_input: token_cost(usage.cache_read_input_tokens, effective.cache_read_input),
-          cache_write_input: token_cost(usage.cache_write_input_tokens, effective.cache_write_input),
-          output: token_cost(usage.output_tokens, effective.output)
-        }
+        return nil if effective.value?(nil)
+
+        usage.price_quantities.to_h do |key, tokens|
+          [key, token_cost(tokens, effective.fetch(key))]
+        end
       end
 
       def token_cost(tokens, per_million_price)

data/lib/llm_cost_tracker/railtie.rb

@@ -2,13 +2,19 @@
 
 module LlmCostTracker
   class Railtie < Rails::Railtie
+    initializer "llm_cost_tracker.app_models_autoload_paths", before: :set_autoload_paths do |app|
+      models_path = File.expand_path("../../app/models", __dir__)
+      app.config.autoload_paths << models_path unless app.config.autoload_paths.include?(models_path)
+      app.config.eager_load_paths << models_path unless app.config.eager_load_paths.include?(models_path)
+    end
+
     generators do
       require_relative "generators/llm_cost_tracker/add_ingestion_generator"
       require_relative "generators/llm_cost_tracker/add_period_totals_generator"
       require_relative "generators/llm_cost_tracker/add_latency_ms_generator"
       require_relative "generators/llm_cost_tracker/add_provider_response_id_generator"
       require_relative "generators/llm_cost_tracker/add_streaming_generator"
-      require_relative "generators/llm_cost_tracker/add_usage_breakdown_generator"
+      require_relative "generators/llm_cost_tracker/add_token_usage_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"
@@ -18,12 +24,5 @@ module LlmCostTracker
     rake_tasks do
       load File.expand_path("../tasks/llm_cost_tracker.rake", __dir__)
     end
-
-    initializer "llm_cost_tracker.configure" do
-      ActiveSupport.on_load(:active_record) do
-        require_relative "llm_api_call"
-        require_relative "storage/active_record_store"
-      end
-    end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/integer/time"
+
+require_relative "../ledger"
+
+module LlmCostTracker
+  class Report
+    Data = ::Data.define(
+      :days,
+      :from_time,
+      :to_time,
+      :total_cost,
+      :requests_count,
+      :average_latency_ms,
+      :unknown_pricing_count,
+      :cost_by_provider,
+      :cost_by_model,
+      :cost_by_tags,
+      :top_calls
+    )
+
+    class Data
+      DEFAULT_DAYS = 30
+      TOP_LIMIT = 5
+
+      def self.build(days: DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil, breakdown_limit: nil)
+        days = days.to_i
+        days = DEFAULT_DAYS unless days.positive?
+        unless breakdown_limit.nil?
+          breakdown_limit = breakdown_limit.to_i
+          breakdown_limit = nil unless breakdown_limit.positive?
+        end
+        from = now - days.days
+        scope = Ledger::Call.where(tracked_at: from..now)
+        tag_breakdowns ||= LlmCostTracker.configuration.report_tag_breakdowns || []
+
+        new(
+          days: days,
+          from_time: from,
+          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: scope.cost_by_provider(limit: breakdown_limit).to_a,
+          cost_by_model: scope.cost_by_model(limit: breakdown_limit).to_a,
+          cost_by_tags: cost_by_tags(scope, tag_breakdowns, limit: breakdown_limit),
+          top_calls: top_calls(scope)
+        )
+      end
+
+      def self.average_latency_ms(scope)
+        scope.average(:latency_ms)&.to_f
+      end
+
+      def self.cost_by_tags(scope, keys, limit:)
+        keys.to_h { |key| [key, scope.cost_by_tag(key, limit: limit).to_a] }
+      end
+
+      def self.top_calls(scope)
+        scope
+          .where.not(total_cost: nil)
+          .order(total_cost: :desc)
+          .limit(TOP_LIMIT)
+          .to_a
+      end
+
+      private_class_method :average_latency_ms, :cost_by_tags, :top_calls
+    end
+  end
+end

data/lib/llm_cost_tracker/report/formatter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class Report
+    class Formatter
+      TOP_LIMIT = 5
+      NAME_COLUMN_WIDTH = 28
+      TOP_CALL_COLUMN_WIDTH = 32
+
+      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_tag_sections(lines)
+        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 |row|
+          lines << "  #{row.name.to_s.ljust(NAME_COLUMN_WIDTH)} #{money(row.total_cost)}"
+        end
+      end
+
+      def append_tag_sections(lines)
+        @data.cost_by_tags.each do |tag_key, rows|
+          append_cost_section(lines, "By tag (#{tag_key})", rows)
+        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(TOP_CALL_COLUMN_WIDTH)} #{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
+end

data/lib/llm_cost_tracker/report.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require_relative "report_data"
-require_relative "report_formatter"
+require_relative "report/data"
+require_relative "report/formatter"
 
 module LlmCostTracker
   class Report
     class << self
-      def generate(days: ReportData::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
-        report_data = ReportData.build(
+      def generate(days: Data::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
+        report_data = Data.build(
           days: days,
           now: now,
           tag_breakdowns: tag_breakdowns,
-          breakdown_limit: ReportFormatter::TOP_LIMIT
+          breakdown_limit: Formatter::TOP_LIMIT
         )
 
-        ReportFormatter.new(report_data).to_s
+        Formatter.new(report_data).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: ReportData::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
-        ReportData.build(days: days, now: now, tag_breakdowns: tag_breakdowns)
+      def data(days: Data::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
+        Data.build(days: days, now: now, tag_breakdowns: tag_breakdowns)
       end
     end
   end

data/lib/llm_cost_tracker/retention.rb

@@ -6,22 +6,23 @@ module LlmCostTracker
 
     class << self
       def prune(older_than:, batch_size: DEFAULT_BATCH_SIZE, now: Time.now.utc)
-        batch_size = normalized_batch_size(batch_size)
+        batch_size = batch_size.to_i
+        raise ArgumentError, "batch_size must be positive: #{batch_size.inspect}" unless batch_size.positive?
+
         cutoff = resolve_cutoff(older_than, now)
-        require_relative "storage/active_record_backend"
+        require_relative "ledger"
 
-        Storage::ActiveRecordBackend.prune(cutoff: cutoff, batch_size: batch_size)
+        deleted = 0
+        loop do
+          batch = prune_batch(cutoff, batch_size)
+          deleted += batch
+          break if batch < batch_size
+        end
+        deleted
       end
 
       private
 
-      def normalized_batch_size(value)
-        value = value.to_i
-        raise ArgumentError, "batch_size must be positive: #{value.inspect}" unless value.positive?
-
-        value
-      end
-
       def resolve_cutoff(older_than, now)
         cutoff = case older_than
                  when Time, DateTime then older_than.utc
@@ -46,6 +47,22 @@ module LlmCostTracker
 
         now - (days * 86_400)
       end
+
+      def prune_batch(cutoff, batch_size)
+        LlmCostTracker::Ledger::Call.transaction do
+          rows = LlmCostTracker::Ledger::Call
+                 .where(tracked_at: ...cutoff)
+                 .order(:id)
+                 .limit(batch_size)
+                 .lock
+                 .pluck(:id, :tracked_at, :total_cost)
+          next 0 if rows.empty?
+
+          deleted = LlmCostTracker::Ledger::Call.where(id: rows.map(&:first)).delete_all
+          LlmCostTracker::Ledger::Rollups.decrement!(rows) if deleted.positive?
+          deleted
+        end
+      end
     end
   end
 end

data/lib/llm_cost_tracker/tags/context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+require "active_support/isolated_execution_state"
+
+module LlmCostTracker
+  module Tags
+    module Context
+      KEY = :llm_cost_tracker_tags
+
+      class << self
+        def with(tags)
+          stack = ActiveSupport::IsolatedExecutionState[KEY] || []
+          ActiveSupport::IsolatedExecutionState[KEY] = stack + [(tags || {}).deep_dup.to_h]
+          yield
+        ensure
+          ActiveSupport::IsolatedExecutionState[KEY] = stack
+        end
+
+        def tags
+          default_tags = LlmCostTracker.configuration.default_tags
+          default_tags = default_tags.call if default_tags.respond_to?(:call)
+
+          (default_tags || {}).deep_dup.to_h.merge(
+            (ActiveSupport::IsolatedExecutionState[KEY] || []).reduce({}) { |merged, tags| merged.merge(tags) }
+          )
+        end
+
+        def clear!
+          ActiveSupport::IsolatedExecutionState[KEY] = []
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tags/key.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Tags
+    module Key
+      PATTERN = /\A[\w.-]+\z/
+
+      class << self
+        def validate!(key, error_class: ArgumentError)
+          key = key.to_s
+          return key if key.match?(PATTERN)
+
+          raise error_class, "invalid tag key: #{key.inspect}"
+        end
+      end
+    end
+  end
+end