llm_cost_tracker 0.7.0 → 0.7.2

data/lib/llm_cost_tracker/price_registry.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "monitor"
-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 output cache_read_input cache_write_input].freeze
-    METADATA_KEYS = %w[_source _source_version _fetched_at _updated _notes _validator_override].freeze
-    MAX_FILE_BYTES = 2_097_152
-    MUTEX = Monitor.new
-
-    class << self
-      def builtin_prices
-        @builtin_prices ||= MUTEX.synchronize do
-          @builtin_prices || normalize_price_table(raw_registry.fetch("models", {})).freeze
-        end
-      end
-
-      def metadata
-        @metadata ||= MUTEX.synchronize { @metadata || raw_registry.fetch("metadata", {}).freeze }
-      end
-
-      def file_metadata(path)
-        return {} unless path
-
-        registry = load_price_file(path.to_s)
-        raise ArgumentError, "prices_file must be a hash" unless registry.is_a?(Hash)
-
-        metadata = registry.fetch("metadata", {})
-        raise ArgumentError, "prices_file metadata must be a hash" unless metadata.is_a?(Hash)
-
-        metadata
-      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
-        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
-      end
-
-      def normalize_price_table(table)
-        normalize_price_entries(table, context: "price table")
-      end
-
-      def file_prices(path)
-        return EMPTY_PRICES unless path
-
-        path = path.to_s
-        cache_key = [path, File.mtime(path).to_f]
-        cached = @file_prices_cache
-        return cached[:value] if cached && cached[:key] == cache_key
-
-        MUTEX.synchronize do
-          cached = @file_prices_cache
-          return cached[:value] if cached && cached[:key] == cache_key
-
-          value = normalize_file_prices(price_file_models(load_price_file(path)), path: path).freeze
-          @file_prices_cache = { key: cache_key, value: value }.freeze
-          value
-        end
-      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
-        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
-      end
-
-      private
-
-      def raw_registry
-        @raw_registry ||= MUTEX.synchronize do
-          @raw_registry || JSON.parse(File.read(DEFAULT_PRICES_PATH)).freeze
-        end
-      end
-
-      def normalize_price_entry(price)
-        price.each_with_object({}) do |(key, value), normalized|
-          key = key.to_s
-          normalized[key.to_sym] = Float(value) if price_key?(key)
-        end
-      end
-
-      def normalize_file_prices(table, 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
-
-      def warn_unknown_keys(model, price, path)
-        unknown_keys = price.keys.map(&:to_s).reject do |key|
-          price_key?(key) || METADATA_KEYS.include?(key)
-        end
-        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}; mode-specific keys use mode_input"
-        )
-      end
-
-      def price_key?(key)
-        return true if PRICE_KEYS.include?(key)
-
-        PRICE_KEYS.any? do |base_key|
-          key.end_with?("_#{base_key}") && key.delete_suffix("_#{base_key}") != ""
-        end
-      end
-
-      def load_price_file(path)
-        raise ArgumentError, "prices_file exceeds #{MAX_FILE_BYTES} bytes" if File.size(path) > MAX_FILE_BYTES
-
-        contents = File.read(path)
-        return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)
-
-        JSON.parse(contents)
-      end
-
-      def yaml_file?(path)
-        %w[.yaml .yml].include?(File.extname(path).downcase)
-      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/fetcher.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-require "net/http"
-require "openssl"
-require "time"
-require "uri"
-
-module LlmCostTracker
-  module PriceSync
-    class Fetcher
-      Response = Data.define(:body, :etag, :last_modified, :not_modified, :fetched_at) do
-        def source_version
-          etag || last_modified || Digest::SHA256.hexdigest(body.to_s)
-        end
-      end
-
-      USER_AGENT = "llm_cost_tracker price refresh"
-      MAX_REDIRECTS = 5
-      MAX_BODY_BYTES = 2_097_152
-      OPEN_TIMEOUT = 5
-      READ_TIMEOUT = 10
-      WRITE_TIMEOUT = 10
-
-      def get(url, etag: nil, redirects: 0)
-        raise Error, "Too many redirects while fetching #{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)
-
-        case response
-        when Net::HTTPSuccess
-          build_response(response, body: body || limited_body(response), 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 #{url}" if location.nil? || location.empty?
-
-          get(URI.join(url, location).to_s, etag: etag, redirects: redirects + 1)
-        else
-          raise Error, "Unable to fetch #{url}: HTTP #{response.code}"
-        end
-      rescue OpenSSL::SSL::SSLError, SocketError, SystemCallError, Timeout::Error => e
-        raise Error, "Unable to fetch #{url}: #{e.class}: #{e.message}"
-      end
-
-      private
-
-      def fetch_response(uri, request)
-        body = nil
-        response = Net::HTTP.start(
-          uri.host,
-          uri.port,
-          use_ssl: uri.scheme == "https",
-          open_timeout: OPEN_TIMEOUT,
-          read_timeout: READ_TIMEOUT,
-          write_timeout: WRITE_TIMEOUT
-        ) do |http|
-          http.request(request) do |streamed_response|
-            body = limited_body(streamed_response) if streamed_response.is_a?(Net::HTTPSuccess)
-          end
-        end
-
-        [response, body]
-      end
-
-      def limited_body(response)
-        body = +""
-        if response.respond_to?(:read_body)
-          response.read_body do |chunk|
-            chunk = chunk.to_s
-            if body.bytesize + chunk.bytesize > MAX_BODY_BYTES
-              raise Error, "Pricing snapshot response exceeds #{MAX_BODY_BYTES} bytes"
-            end
-
-            body << chunk
-          end
-        else
-          body = response.body.to_s
-        end
-        raise Error, "Pricing snapshot response exceeds #{MAX_BODY_BYTES} bytes" if body.bytesize > MAX_BODY_BYTES
-
-        body
-      end
-
-      def build_response(response, not_modified:, body: response.body)
-        Response.new(
-          body: body,
-          etag: response["etag"],
-          last_modified: response["last-modified"],
-          not_modified: not_modified,
-          fetched_at: Time.now.utc.iso8601
-        )
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/registry_diff.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module PriceSync
-    module RegistryDiff
-      class << self
-        def call(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
-
-        private
-
-        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 normalize_models(models)
-          normalize_hash(models).transform_values { |entry| normalize_hash(entry) }
-        end
-
-        def normalize_hash(hash)
-          return {} if hash.nil?
-          raise Error, "pricing entries must be hashes" unless hash.is_a?(Hash)
-
-          hash.each_with_object({}) do |(key, value), normalized|
-            normalized[key.to_s] = value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/registry_loader.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "yaml"
-
-require_relative "../price_registry"
-
-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)
-        if File.size(path) > PriceRegistry::MAX_FILE_BYTES
-          raise ArgumentError, "pricing registry exceeds #{PriceRegistry::MAX_FILE_BYTES} bytes"
-        end
-
-        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

@@ -1,29 +0,0 @@
-# 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"
-        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

data/lib/llm_cost_tracker/price_sync.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "json"
-require "rubygems"
-
-require_relative "price_sync/fetcher"
-require_relative "price_sync/registry_diff"
-require_relative "price_sync/registry_loader"
-require_relative "price_sync/registry_writer"
-
-module LlmCostTracker
-  module PriceSync
-    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
-        return output unless output.empty?
-
-        prices_file = config.prices_file
-        return prices_file.to_s if prices_file
-
-        default_output_path
-      end
-
-      def configured_remote_url(env: ENV)
-        url = env["URL"].to_s.strip
-        url.empty? ? DEFAULT_REMOTE_URL : url
-      end
-
-      def refresh(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, preview: false, fetcher: Fetcher.new,
-                  today: Date.today)
-        current = load_current_registry(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 = load_current_registry(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 defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-          Rails.root.join(DEFAULT_OUTPUT_PATH).to_s
-        else
-          DEFAULT_OUTPUT_PATH
-        end
-      end
-
-      def load_current_registry(path)
-        RegistryLoader.new.call(path: path, seed_path: PriceRegistry::DEFAULT_PRICES_PATH)
-      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", {})
-        PriceRegistry.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

data/lib/llm_cost_tracker/report_data.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/integer/time"
-
-module LlmCostTracker
-  TopCall = Data.define(:provider, :model, :total_cost)
-
-  ReportData = 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 ReportData
-    DEFAULT_DAYS = 30
-    TOP_LIMIT = 5
-
-    def self.build(days: DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil, breakdown_limit: nil)
-      require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
-
-      days = normalized_days(days)
-      breakdown_limit = normalized_limit(breakdown_limit)
-      from = now - days.days
-      scope = LlmApiCall.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: cost_by(scope, :provider, limit: breakdown_limit),
-        cost_by_model: cost_by(scope, :model, limit: breakdown_limit),
-        cost_by_tags: cost_by_tags(scope, tag_breakdowns, limit: breakdown_limit),
-        top_calls: top_calls(scope)
-      )
-    end
-
-    def self.normalized_days(days)
-      days = days.to_i
-      days.positive? ? days : DEFAULT_DAYS
-    end
-
-    def self.normalized_limit(limit)
-      return nil if limit.nil?
-
-      limit = limit.to_i
-      limit.positive? ? limit : nil
-    end
-
-    def self.average_latency_ms(scope)
-      return nil unless LlmApiCall.latency_column?
-
-      scope.average(:latency_ms)&.to_f
-    end
-
-    def self.cost_by(scope, column, limit:)
-      relation = scope.group(column)
-                      .order(Arel.sql("COALESCE(SUM(total_cost), 0) DESC"))
-
-      relation = relation.limit(limit) if limit
-
-      relation
-        .sum(:total_cost)
-        .transform_values(&:to_f)
-        .sort_by { |_name, cost| -cost }
-    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)
-        .map { |call| TopCall.new(provider: call.provider, model: call.model, total_cost: call.total_cost.to_f) }
-    end
-
-    private_class_method :normalized_days, :normalized_limit, :average_latency_ms, :cost_by, :cost_by_tags, :top_calls
-  end
-end

data/lib/llm_cost_tracker/report_formatter.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  class ReportFormatter
-    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 |name, cost|
-        lines << "  #{name.to_s.ljust(NAME_COLUMN_WIDTH)} #{money(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