llm_cost_tracker 0.14.2 → 0.15.0

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -1,23 +1,22 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
-require "bigdecimal/util"
 require "yaml"
 
 require_relative "../usage/catalog"
-require_relative "../pricing/rate"
 require_relative "../logging"
-require_relative "mode"
-require_relative "price_key"
 require_relative "source"
+require_relative "registry/normalizer"
 
 module LlmCostTracker
   module Pricing
     module Registry
       DEFAULT_PRICES_PATH = File.expand_path("../prices.json", __dir__)
       CONTEXT_THRESHOLD_KEY = "_context_price_threshold_tokens"
+      OFF_PEAK_WINDOWS_KEY = "_off_peak_windows"
+      MINIMUM_BILLED_SECONDS_KEY = "_minimum_billed_seconds"
       PRICE_KEYS = Usage::Catalog.all.select(&:token?).map(&:key).freeze
-      METADATA_KEYS = ["_source", CONTEXT_THRESHOLD_KEY].freeze
+      METADATA_KEYS = ["_source", CONTEXT_THRESHOLD_KEY, OFF_PEAK_WINDOWS_KEY, MINIMUM_BILLED_SECONDS_KEY].freeze
 
       class << self
         def reset!
@@ -66,13 +65,7 @@ module LlmCostTracker
         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)
-            normalized[model.to_s] = normalize_price_entry(model, price, context)
-          end
+          Normalizer.new(context).prices(table)
         end
 
         def raw_registry
@@ -96,14 +89,7 @@ module LlmCostTracker
         end
 
         def rates_from_registry(registry, context:)
-          data = registry.fetch("service_charges", {})
-          raise ArgumentError, "#{context} service_charges must be a hash" unless data.is_a?(Hash)
-
-          currency = upcased_currency(registry.dig("metadata", "currency"))
-          data.each_with_object({}) do |(provider, entries), rates|
-            section_context = "#{context} service_charges.#{provider}"
-            rates[provider] = rates_from_section(entries, currency: currency, context: section_context)
-          end
+          Normalizer.new(context).rates(registry)
         end
 
         def prices_file_mtime_iso
@@ -114,32 +100,7 @@ module LlmCostTracker
         end
 
         def sources
-          @sources ||= begin
-            config = LlmCostTracker.configuration
-            [
-              Source.new(
-                name: "pricing_overrides",
-                prices: config.pricing.overrides,
-                rates: {},
-                currency: upcased_currency(nil),
-                version: "configuration"
-              ),
-              Source.new(
-                name: "prices_file",
-                prices: file_prices(config.pricing.file),
-                rates: file_rates(config.pricing.file),
-                currency: upcased_currency(file_metadata(config.pricing.file)["currency"]),
-                version: prices_file_mtime_iso
-              ),
-              Source.new(
-                name: "bundled",
-                prices: builtin_prices,
-                rates: builtin_rates,
-                currency: upcased_currency(metadata["currency"]),
-                version: LlmCostTracker::VERSION
-              )
-            ].freeze
-          end
+          @sources ||= [overrides_source, file_source, bundled_source].freeze
         end
 
         def sorted_price_keys(table)
@@ -150,6 +111,37 @@ module LlmCostTracker
 
         private
 
+        def overrides_source
+          Source.new(
+            name: "pricing_overrides",
+            prices: LlmCostTracker.configuration.pricing.overrides,
+            rates: {},
+            currency: upcased_currency(nil),
+            version: "configuration"
+          )
+        end
+
+        def file_source
+          path = LlmCostTracker.configuration.pricing.file
+          Source.new(
+            name: "prices_file",
+            prices: file_prices(path),
+            rates: file_rates(path),
+            currency: upcased_currency(file_metadata(path)["currency"]),
+            version: prices_file_mtime_iso
+          )
+        end
+
+        def bundled_source
+          Source.new(
+            name: "bundled",
+            prices: builtin_prices,
+            rates: builtin_rates,
+            currency: upcased_currency(metadata["currency"]),
+            version: LlmCostTracker::VERSION
+          )
+        end
+
         def memoize_in(cache, key, identity: false)
           existing = cache && cache[key]
           return [existing, cache] if existing
@@ -182,75 +174,10 @@ module LlmCostTracker
           end
         end
 
-        def normalize_price_entry(model, price, context)
-          unknown = []
-          normalized = price.each_with_object({}) do |(key, value), acc|
-            if key.to_s == CONTEXT_THRESHOLD_KEY
-              acc[CONTEXT_THRESHOLD_KEY] = Integer(value)
-            elsif (registry_key = PriceKey.price_key_for(key))
-              acc[registry_key] = non_negative_decimal(value, label: "price for #{registry_key.inspect}")
-            elsif !METADATA_KEYS.include?(key)
-              unknown << key
-            end
-          end
-          warn_unknown_keys(model, unknown, context) unless unknown.empty?
-          normalized
-        end
-
-        def non_negative_decimal(value, label:)
-          decimal = BigDecimal(value.to_s)
-          raise ArgumentError, "#{label} must be finite (got #{value})" unless decimal.finite?
-          raise ArgumentError, "#{label} must be non-negative (got #{value})" if decimal.negative?
-
-          decimal
-        end
-
-        def warn_unknown_keys(model, unknown_keys, path)
-          Logging.warn(
-            "Unknown price keys #{unknown_keys.inspect} for #{model.inspect} in #{path}; " \
-            "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}; mode-specific keys use mode_input"
-          )
-        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
-
         def load_file_rates(path)
           loading(path) { rates_from_registry(raw_file_registry(path), context: path).freeze }
         end
 
-        def rates_from_section(entries, currency:, context:)
-          raise ArgumentError, "#{context} must be a hash" unless entries.is_a?(Hash)
-
-          entries.each_with_object({}) do |(key, amount), rates|
-            key = key.to_s
-            dimension, tier = dimension_and_tier_for(key, context: context)
-            amount = non_negative_decimal(amount, label: "service charge price amount for #{key.inspect} in #{context}")
-
-            rate = {
-              amount: amount,
-              quantity: Pricing::RATE_BASIS_QUANTITIES.fetch(dimension.rate_basis).to_d,
-              currency: currency,
-              source_key: key
-            }
-            dimension_rates = rates[dimension.key] ||= { tiers: {} }
-            (tier ? dimension_rates[:tiers] : dimension_rates)[tier || :default] = rate
-          end
-        end
-
-        def dimension_and_tier_for(key, context:)
-          dimension, tier = PriceKey.parse_dimension_key(key)
-          unless dimension && dimension.token_key.nil?
-            raise ArgumentError, "service charge price key #{key.inspect} in #{context} uses unknown billing dimension"
-          end
-
-          [dimension, tier]
-        end
-
         def upcased_currency(value)
           (value || LlmCostTracker::DEFAULT_CURRENCY).upcase
         end

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

@@ -3,34 +3,54 @@
 module LlmCostTracker
   module Pricing
     module Sync
-      module ChangePrinter
+      class ChangePrinter
         def self.call(changes, suspicious: [], output: $stdout)
-          if suspicious.any?
-            output.puts "  suspicious changes (refresh writes them only with FORCE=1): #{suspicious.size}"
-            suspicious.each { |finding| output.puts "    - #{finding}" }
-          end
+          new(output).call(changes, suspicious)
+        end
+
+        def initialize(output)
+          @output = output
+        end
+
+        def call(changes, suspicious)
+          print_suspicious(suspicious)
+          print_models(changes.except("service_charges"))
+          print_service_charges(changes["service_charges"])
+        end
+
+        private
 
-          service_changes = changes["service_charges"]
-          model_changes = changes.except("service_charges")
+        def print_suspicious(findings)
+          return unless findings.any?
 
-          output.puts "  changed models: #{model_changes.size}"
-          model_changes.each do |model, fields|
-            output.puts "    - #{model}"
-            fields.each do |field, values|
-              output.puts "      #{field}: #{values['from'].inspect} -> #{values['to'].inspect}"
-            end
+          @output.puts "  suspicious changes (refresh writes them only with FORCE=1): #{findings.size}"
+          findings.each { |finding| @output.puts "    - #{finding}" }
+        end
+
+        def print_models(changes)
+          @output.puts "  changed models: #{changes.size}"
+          changes.each do |model, fields|
+            @output.puts "    - #{model}"
+            fields.each { |field, values| @output.puts "      #{field}: #{transition(values)}" }
           end
+        end
 
-          return if service_changes.nil? || service_changes.empty?
+        def print_service_charges(changes)
+          return if changes.nil? || changes.empty?
 
-          output.puts "  changed service charges: #{service_changes.values.sum(&:size)}"
-          service_changes.each do |provider, components|
-            components.each do |component, values|
-              output.puts "    - #{provider}.#{component}: " \
-                          "#{values['from'].inspect} -> #{values['to'].inspect}"
-            end
+          @output.puts "  changed service charges: #{changes.values.sum(&:size)}"
+          changes.each do |provider, components|
+            components.each { |component, values| @output.puts "    - #{provider}.#{component}: #{transition(values)}" }
           end
         end
+
+        def transition(values)
+          "#{shown(values['from'])} -> #{shown(values['to'])}"
+        end
+
+        def shown(value)
+          value.is_a?(BigDecimal) ? value.to_s("F") : value.inspect
+        end
       end
     end
   end

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

@@ -26,55 +26,57 @@ module LlmCostTracker
         READ_TIMEOUT = 10
         WRITE_TIMEOUT = 10
 
+        def self.scrub_url(url)
+          uri = URI.parse(url.to_s)
+          uri.user = nil
+          uri.password = nil
+          uri.query = nil
+          uri.fragment = nil
+          uri.to_s
+        rescue URI::InvalidURIError
+          "[invalid url]"
+        end
+
         def get(url, etag: nil, redirects: 0)
-          safe_url = scrub_url(url)
+          safe_url = self.class.scrub_url(url)
           raise Error, "Too many redirects while fetching #{safe_url}" if redirects > MAX_REDIRECTS
 
-          uri = URI.parse(url)
-          raise Error, "Pricing snapshot URL must use https" unless uri.scheme == "https"
-
-          request = Net::HTTP::Get.new(uri)
-          request["User-Agent"] = USER_AGENT
-          request["If-None-Match"] = etag if etag
-
-          response, body = fetch_response(uri, request)
-
+          response, body = fetch_response(https_uri(url), etag)
           case response
-          when Net::HTTPSuccess
-            build_response(response, body: body, not_modified: false)
-          when Net::HTTPNotModified
-            build_response(response, body: nil, not_modified: true)
-          when Net::HTTPRedirection
-            location = response["location"]
-            raise Error, "Redirect without location while fetching #{safe_url}" if location.blank?
-
-            get(URI.join(url, location).to_s, etag: etag, redirects: redirects + 1)
-          else
-            raise Error, "Unable to fetch #{safe_url}: HTTP #{response.code}"
+          when Net::HTTPSuccess then build_response(response, body: body, not_modified: false)
+          when Net::HTTPNotModified then build_response(response, body: nil, not_modified: true)
+          when Net::HTTPRedirection then get(redirect_url(url, response), etag: etag, redirects: redirects + 1)
+          else raise Error, "Unable to fetch #{safe_url}: HTTP #{response.code}"
           end
         rescue OpenSSL::SSL::SSLError, SocketError, SystemCallError, Timeout::Error => e
-          raise Error, "Unable to fetch #{scrub_url(url)}: #{e.class}: #{e.message}"
+          raise Error, "Unable to fetch #{self.class.scrub_url(url)}: #{e.class}: #{e.message}"
         end
 
         private
 
-        def scrub_url(url)
-          uri = URI.parse(url.to_s)
-          uri.user = nil
-          uri.password = nil
-          uri.query = nil
-          uri.fragment = nil
-          uri.to_s
-        rescue URI::InvalidURIError
-          "[invalid url]"
+        def https_uri(url)
+          uri = URI.parse(url)
+          raise Error, "Pricing snapshot URL must use https" unless uri.scheme == "https"
+
+          uri
+        end
+
+        def redirect_url(url, response)
+          location = response["location"]
+          raise Error, "Redirect without location while fetching #{self.class.scrub_url(url)}" if location.blank?
+
+          URI.join(url, location).to_s
         end
 
-        def fetch_response(uri, request)
+        def fetch_response(uri, etag)
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = USER_AGENT
+          request["If-None-Match"] = etag if etag
           body = nil
           response = Net::HTTP.start(
             uri.host,
             uri.port,
-            use_ssl: uri.scheme == "https",
+            use_ssl: true,
             open_timeout: OPEN_TIMEOUT,
             read_timeout: READ_TIMEOUT,
             write_timeout: WRITE_TIMEOUT
@@ -83,7 +85,6 @@ module LlmCostTracker
               body = limited_body(streamed_response) if streamed_response.is_a?(Net::HTTPSuccess)
             end
           end
-
           [response, body]
         end
 

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

@@ -5,6 +5,8 @@ require "fileutils"
 require "json"
 require "yaml"
 
+require_relative "../registry"
+
 module LlmCostTracker
   module Pricing
     module Sync
@@ -12,6 +14,10 @@ module LlmCostTracker
         YAML_EXTENSIONS = %w[.yml .yaml].freeze
         MANUAL_SOURCE = "manual"
 
+        def initialize(keep_unlisted: true)
+          @keep_unlisted = keep_unlisted
+        end
+
         def call(path:, registry:)
           payload = render(path: path, registry: registry)
           FileUtils.mkdir_p(File.dirname(path))
@@ -23,23 +29,9 @@ module LlmCostTracker
         end
 
         def render(path:, registry:)
-          merged = canonicalize(merge_with_existing(path: path, registry: registry))
-          yaml_file?(path) ? YAML.dump(merged) : "#{JSON.pretty_generate(merged)}\n"
-        end
-
-        private
-
-        def canonicalize(value)
-          case value
-          when Hash
-            value.sort_by { |key, _| key.to_s }.to_h { |key, nested| [key, canonicalize(nested)] }
-          when Array
-            value.map { |element| canonicalize(element) }
-          when BigDecimal
-            value.to_f
-          else
-            value
-          end
+          json = !yaml_file?(path)
+          merged = canonicalize(merge_with_existing(path: path, registry: registry), json: json)
+          json ? "#{JSON.pretty_generate(merged)}\n" : YAML.dump(merged)
         end
 
         def merge_with_existing(path:, registry:)
@@ -54,10 +46,25 @@ module LlmCostTracker
           merged
         end
 
+        private
+
+        def canonicalize(value, json:)
+          case value
+          when Hash then value.sort_by { |key, _| key.to_s }.to_h { |key, item| [key, canonicalize(item, json: json)] }
+          when Array then value.map { |item| canonicalize(item, json: json) }
+          when BigDecimal, Float then canonical_number(value, json: json)
+          else value
+          end
+        end
+
+        def canonical_number(value, json:)
+          json && defined?(JSON::Fragment) ? JSON::Fragment.new(value.to_f.to_s) : value.to_f
+        end
+
         def merged_models(registry, existing)
           merged = registry.fetch("models", {}).dup
           existing.fetch("models", {}).each do |model, attrs|
-            next unless attrs.is_a?(Hash) && attrs["_source"].to_s == MANUAL_SOURCE
+            next unless attrs.is_a?(Hash) && own_entry?(model, attrs)
             next if merged.key?(model)
 
             merged[model] = attrs
@@ -65,6 +72,10 @@ module LlmCostTracker
           merged
         end
 
+        def own_entry?(model, attrs)
+          attrs["_source"].to_s == MANUAL_SOURCE || (@keep_unlisted && !Registry.builtin_prices.key?(model))
+        end
+
         def merged_service_charges(registry, existing)
           remote = registry.fetch("service_charges", {})
           existing.fetch("service_charges", {}).each_with_object(remote.dup) do |(provider, charges), merged|

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "json"
+require "rubygems"
+
+require_relative "fetcher"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      class RemoteSnapshot
+        CONTEXT = "remote pricing snapshot"
+
+        def initialize(body)
+          @registry = parse(body)
+          @metadata = @registry.fetch("metadata", {})
+          raise Error, "remote pricing metadata must be a hash" unless @metadata.is_a?(Hash)
+        end
+
+        def registry(url:, source_version:, today:)
+          check_compatibility!
+          models = models_with_metadata
+          Registry.rates_from_registry(@registry, context: CONTEXT) if service_charges
+          {
+            "metadata" => @metadata.merge(
+              "schema_version" => schema_version,
+              "updated_at" => @metadata["updated_at"] || today.iso8601,
+              "source_url" => Fetcher.scrub_url(url),
+              "source_version" => source_version
+            ),
+            "models" => models,
+            "service_charges" => service_charges.presence
+          }.compact
+        rescue ArgumentError, TypeError => e
+          raise Error, "Unable to load remote pricing snapshot: #{e.message}"
+        end
+
+        private
+
+        def parse(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 check_compatibility!
+          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"]
+          return unless 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
+
+        def schema_version
+          @schema_version ||= Integer(@metadata.fetch("schema_version", 1))
+        end
+
+        def models_with_metadata
+          raw_models = @registry.fetch("models", {})
+          Registry.normalize_price_entries(raw_models, context: CONTEXT).to_h do |model, prices|
+            [model, (raw_models[model] || {}).slice(*Registry::METADATA_KEYS).merge(prices)]
+          end
+        end
+
+        def service_charges
+          @registry["service_charges"]
+        end
+      end
+    end
+  end
+end

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

@@ -22,6 +22,8 @@ module LlmCostTracker
           private
 
           def finding(label, field, values)
+            return if field == Registry::OFF_PEAK_WINDOWS_KEY
+
             from, to = values.values_at("from", "to").map { |value| value&.to_f }
             "#{label}: #{from.inspect} -> #{to.inspect}" if suspicious?(field, from, to)
           end

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -2,13 +2,12 @@
 
 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_writer"
+require_relative "sync/remote_snapshot"
 require_relative "sync/snapshot_guard"
 
 module LlmCostTracker
@@ -52,7 +51,7 @@ module LlmCostTracker
           end
           RefreshResult.new(
             path: path,
-            source_url: Redaction.text(url),
+            source_url: Fetcher.scrub_url(url),
             source_version: response.source_version,
             changes: changes,
             suspicious: suspicious,
@@ -65,7 +64,7 @@ module LlmCostTracker
           response, _remote, changes, suspicious = compare(path, url, fetcher, today)
           CheckResult.new(
             path: path,
-            source_url: Redaction.text(url),
+            source_url: Fetcher.scrub_url(url),
             source_version: response.source_version,
             changes: changes,
             suspicious: suspicious,
@@ -75,51 +74,15 @@ module LlmCostTracker
 
         private
 
-        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
-
-          raw_models = registry.fetch("models", {})
-          models = Registry.normalize_price_entries(raw_models, context: "remote pricing snapshot")
-                           .each_with_object({}) do |(model, prices), normalized|
-            model_metadata = (raw_models[model] || {}).slice(*Registry::METADATA_KEYS)
-            normalized[model] = model_metadata.merge(prices)
-          end
-          service_charges = registry["service_charges"]
-          Registry.rates_from_registry(registry, context: "remote pricing snapshot") if service_charges
-
-          normalized = {
-            "metadata" => metadata.merge(
-              "schema_version" => schema_version,
-              "updated_at" => metadata["updated_at"] || today.iso8601,
-              "source_url" => Redaction.text(url),
-              "source_version" => response.source_version
-            ),
-            "models" => models
-          }
-          normalized["service_charges"] = service_charges if service_charges.present?
-          normalized
-        rescue ArgumentError, TypeError => e
-          raise Error, "Unable to load remote pricing snapshot: #{e.message}"
-        end
-
         def compare(path, url, fetcher, today)
           current = load_registry(path)
           response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
           return [response, nil, {}, []] if response.not_modified
 
-          remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+          snapshot = RemoteSnapshot.new(response.body)
+          remote = RegistryWriter.new.merge_with_existing(
+            path: path, registry: snapshot.registry(url: url, source_version: response.source_version, today: today)
+          )
           changes = registry_changes(current, remote)
           [response, remote, changes, SnapshotGuard.call(current: current, remote: remote, changes: changes)]
         end
@@ -132,15 +95,6 @@ module LlmCostTracker
           raise Error, "Unable to load pricing registry #{path.inspect}: #{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 refuse_suspicious_snapshot!(path, suspicious)
           listed = suspicious.first(20).map { |finding| "\n  - #{finding}" }.join
           raise Error,

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -38,7 +38,7 @@ module LlmCostTracker
           subject += " at pricing_mode #{pricing_mode.inspect}" if pricing_mode
           Logging.warn(
             "No pricing configured for #{subject}. " \
-            "Cost and budget guardrails will be skipped for this event. " \
+            "Cost and spend budgets will be skipped for this event. " \
             "Add a pricing.overrides entry or set pricing.unknown_model_behavior."
           )
         end