llm_cost_tracker 0.7.0 → 0.7.1

data/lib/llm_cost_tracker/integrations/object_reader.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Integrations
-    module ObjectReader
-      module_function
-
-      def first(object, *keys)
-        keys.each do |key|
-          value = read(object, key)
-          return value unless value.nil?
-        end
-        nil
-      end
-
-      def nested(object, *path)
-        path.reduce(object) do |current, key|
-          return nil if current.nil?
-
-          read(current, key)
-        end
-      end
-
-      def read(object, key)
-        return nil if object.nil?
-
-        read_hash(object, key) || read_method(object, key) || read_index(object, key)
-      end
-
-      def integer(value)
-        value.nil? ? 0 : value.to_i
-      end
-
-      def read_hash(object, key)
-        return unless object.respond_to?(:key?)
-
-        return object[key] if object.key?(key)
-
-        string_key = key.to_s
-        object[string_key] if object.key?(string_key)
-      end
-
-      def read_method(object, key)
-        object.public_send(key) if object.respond_to?(key)
-      end
-
-      def read_index(object, key)
-        return unless object.respond_to?(:[])
-
-        object[key]
-      rescue IndexError, NameError, TypeError
-        nil
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/integrations/registry.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-require_relative "../errors"
-require_relative "openai"
-require_relative "anthropic"
-require_relative "ruby_llm"
-
-module LlmCostTracker
-  module Integrations
-    module Registry
-      DEFAULT_INTEGRATIONS = {
-        openai: Openai,
-        anthropic: Anthropic,
-        ruby_llm: RubyLlm
-      }.freeze
-      MUTEX = Monitor.new
-
-      module_function
-
-      def register(name, integration)
-        key = name.to_sym
-        validate_integration!(integration)
-        MUTEX.synchronize { @integrations = integrations.merge(key => integration).freeze }
-        integration
-      end
-
-      def install!(names = LlmCostTracker.configuration.instrumented_integrations)
-        normalize(names).each { |name| fetch(name).install }
-      end
-
-      def checks(names = LlmCostTracker.configuration.instrumented_integrations)
-        return [Base::Result.new(:integrations, :ok, "no SDK integrations enabled")] if names.empty?
-
-        normalize(names).map { |name| fetch(name).status }
-      end
-
-      def normalize(names)
-        Array(names).flatten.map(&:to_sym).uniq
-      end
-
-      def fetch(name)
-        integrations.fetch(name.to_sym) do
-          message = "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
-          raise LlmCostTracker::Error, message
-        end
-      end
-
-      def names
-        integrations.keys
-      end
-
-      def reset!
-        MUTEX.synchronize { @integrations = DEFAULT_INTEGRATIONS.dup.freeze }
-      end
-
-      def integrations
-        @integrations || MUTEX.synchronize { @integrations ||= DEFAULT_INTEGRATIONS.dup.freeze }
-      end
-
-      def validate_integration!(integration)
-        return if integration.respond_to?(:install) && integration.respond_to?(:status)
-
-        raise ArgumentError, "integration must respond to install and status"
-      end
-    end
-
-    def self.register(name, integration) = Registry.register(name, integration)
-  end
-end

data/lib/llm_cost_tracker/llm_api_call.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-
-require_relative "llm_api_call_metrics"
-require_relative "period_grouping"
-require_relative "tag_accessors"
-require_relative "tag_query"
-require_relative "tags_column"
-
-module LlmCostTracker
-  class LlmApiCall < ActiveRecord::Base
-    extend PeriodGrouping
-    extend TagsColumn
-    extend LlmApiCallMetrics
-    include TagAccessors
-
-    self.table_name = "llm_api_calls"
-
-    scope :with_cost, -> { where.not(total_cost: nil) }
-    scope :without_cost, -> { where(total_cost: nil) }
-    scope :unknown_pricing, -> { without_cost }
-    scope :with_latency, -> { latency_column? ? where.not(latency_ms: nil) : none }
-    scope :streaming,     -> { stream_column? ? where(stream: true) : none }
-    scope :non_streaming, -> { stream_column? ? where(stream: [false, nil]) : all }
-    scope :by_usage_source, ->(source) { usage_source_column? ? where(usage_source: source.to_s) : none }
-    scope :with_provider_response_id, lambda {
-      provider_response_id_column? ? where.not(provider_response_id: [nil, ""]) : none
-    }
-    scope :missing_provider_response_id, lambda {
-      provider_response_id_column? ? where(provider_response_id: [nil, ""]) : none
-    }
-    scope :streaming_missing_usage, lambda {
-      return none unless stream_column? && usage_source_column?
-
-      where(stream: true).where(usage_source: ["unknown", nil])
-    }
-
-    scope :with_json_tags, lambda {
-      if tags_json_column?
-        where.not(tags: {})
-      else
-        where.not(tags: [nil, "", "{}"])
-      end
-    }
-
-    scope :today,       -> { where(tracked_at: Time.now.utc.beginning_of_day..) }
-    scope :this_week,   -> { where(tracked_at: Time.now.utc.beginning_of_week..) }
-    scope :this_month,  -> { where(tracked_at: Time.now.utc.beginning_of_month..) }
-    scope :between,     ->(from, to) { where(tracked_at: from..to) }
-
-    def self.by_tag(key, value)
-      by_tags(key => value)
-    end
-
-    def self.by_tags(tags)
-      TagQuery.apply(self, tags)
-    end
-  end
-end

data/lib/llm_cost_tracker/llm_api_call_metrics.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tag_sql"
-
-module LlmCostTracker
-  module LlmApiCallMetrics
-    def total_cost
-      sum(:total_cost).to_f
-    end
-
-    def total_tokens
-      sum(:total_tokens).to_i
-    end
-
-    def cost_by_model
-      group(:model).sum(:total_cost)
-    end
-
-    def cost_by_provider
-      group(:provider).sum(:total_cost)
-    end
-
-    def group_by_tag(key)
-      group(Arel.sql(tag_value_expression(key)))
-    end
-
-    def cost_by_tag(key, limit: nil)
-      relation = group_by_tag(key).order(Arel.sql("COALESCE(SUM(total_cost), 0) DESC"))
-      relation = relation.limit(limit) if limit
-
-      costs = relation.sum(:total_cost).each_with_object(Hash.new(0.0)) do |(tag_value, cost), grouped|
-        grouped[tag_value_label(tag_value)] += cost.to_f
-      end
-      costs.sort_by { |_label, cost| -cost }.to_h
-    end
-
-    def average_latency_ms
-      return nil unless latency_column?
-
-      average(:latency_ms)&.to_f
-    end
-
-    def latency_by_model
-      return {} unless latency_column?
-
-      group(:model).average(:latency_ms).transform_values(&:to_f)
-    end
-
-    def latency_by_provider
-      return {} unless latency_column?
-
-      group(:provider).average(:latency_ms).transform_values(&:to_f)
-    end
-
-    def tag_value_label(value)
-      TagSql.value_label(value)
-    end
-
-    def tag_value_expression(key, table_name: quoted_table_name)
-      TagSql.value_expression(self, key, table_name: table_name)
-    end
-  end
-end

data/lib/llm_cost_tracker/parameter_hash.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module ParameterHash
-    class << self
-      def hash_like?(value)
-        value.is_a?(Hash) || action_controller_parameters?(value)
-      end
-
-      def to_hash(value)
-        return {} if value.nil?
-        return value.to_unsafe_h if action_controller_parameters?(value)
-        return value.to_h if value.is_a?(Hash)
-        return {} unless value.respond_to?(:to_h)
-
-        hash = value.to_h
-        hash.is_a?(Hash) ? hash : {}
-      rescue ArgumentError, TypeError
-        {}
-      end
-
-      def with_indifferent_access(value)
-        to_hash(value).with_indifferent_access
-      end
-
-      private
-
-      def action_controller_parameters?(value)
-        defined?(ActionController::Parameters) && value.is_a?(ActionController::Parameters)
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  ParsedUsage = Data.define(
-    :provider,
-    :model,
-    :input_tokens,
-    :output_tokens,
-    :total_tokens,
-    :cache_read_input_tokens,
-    :cache_write_input_tokens,
-    :hidden_output_tokens,
-    :stream,
-    :usage_source,
-    :provider_response_id
-  )
-
-  class ParsedUsage
-    UNKNOWN_MODEL = "unknown"
-    TRACKING_KEYS = %i[
-      provider
-      model
-      input_tokens
-      output_tokens
-      total_tokens
-      stream
-      usage_source
-      provider_response_id
-    ].freeze
-
-    def self.build(**attributes)
-      new(
-        provider: attributes.fetch(:provider),
-        model: normalize_model(attributes.fetch(:model)),
-        input_tokens: attributes.fetch(:input_tokens).to_i,
-        output_tokens: attributes.fetch(:output_tokens).to_i,
-        total_tokens: attributes.fetch(:total_tokens, usage_breakdown(attributes).total_tokens).to_i,
-        cache_read_input_tokens: attributes[:cache_read_input_tokens],
-        cache_write_input_tokens: attributes[:cache_write_input_tokens],
-        hidden_output_tokens: attributes[:hidden_output_tokens],
-        stream: attributes[:stream] || false,
-        usage_source: attributes[:usage_source],
-        provider_response_id: attributes[:provider_response_id]
-      )
-    end
-
-    def metadata
-      to_h.except(*TRACKING_KEYS)
-    end
-
-    def to_h
-      super.compact
-    end
-
-    def self.usage_breakdown(attributes)
-      UsageBreakdown.build(
-        input_tokens: attributes.fetch(:input_tokens),
-        output_tokens: attributes.fetch(:output_tokens),
-        cache_read_input_tokens: attributes[:cache_read_input_tokens],
-        cache_write_input_tokens: attributes[:cache_write_input_tokens],
-        hidden_output_tokens: attributes[:hidden_output_tokens]
-      )
-    end
-    private_class_method :usage_breakdown
-
-    def self.normalize_model(value)
-      model = value.to_s.strip
-      model.empty? ? UNKNOWN_MODEL : model
-    end
-    private_class_method :normalize_model
-  end
-end

data/lib/llm_cost_tracker/parsers/registry.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module LlmCostTracker
-  module Parsers
-    class Registry
-      MUTEX = Monitor.new
-
-      class << self
-        def parsers
-          @parsers || MUTEX.synchronize { @parsers ||= default_parsers.freeze }
-        end
-
-        def register(parser)
-          parser = coerce_parser(parser)
-
-          MUTEX.synchronize do
-            current = @parsers || default_parsers.freeze
-            @parsers = ([parser] + current).freeze
-          end
-
-          parser
-        end
-
-        def find_for(url)
-          parsers.find { |parser| parser.match?(url) }
-        end
-
-        def find_for_provider(provider)
-          provider_name = provider.to_s.downcase
-          parsers.find { |parser| provider_names_for(parser).include?(provider_name) }
-        end
-
-        def reset!
-          MUTEX.synchronize { @parsers = nil }
-        end
-
-        private
-
-        def coerce_parser(parser)
-          return parser.new if parser.is_a?(Class) && parser <= Base
-          return parser if parser.is_a?(Base)
-
-          raise ArgumentError, "parser must be a LlmCostTracker::Parsers::Base instance or class"
-        end
-
-        def provider_names_for(parser)
-          Array(parser.provider_names).map { |name| name.to_s.downcase }
-        end
-
-        def default_parsers
-          [Openai.new, OpenaiCompatible.new, Anthropic.new, Gemini.new]
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/period_grouping.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "active_record_adapter"
-
-module LlmCostTracker
-  module PeriodGrouping
-    PERIOD_FORMATS = {
-      day: {
-        postgres: "YYYY-MM-DD",
-        mysql: "%Y-%m-%d"
-      },
-      month: {
-        postgres: "YYYY-MM",
-        mysql: "%Y-%m"
-      }
-    }.freeze
-
-    private_constant :PERIOD_FORMATS
-
-    def group_by_period(period, column: :tracked_at)
-      group(Arel.sql(period_group_expression(period, column: column)))
-    end
-
-    def daily_costs(days: 30)
-      where(tracked_at: days.days.ago..)
-        .group_by_period(:day)
-        .sum(:total_cost)
-    end
-
-    private
-
-    def period_group_expression(period, column:)
-      period = validated_period(period)
-      column = period_column_expression(column)
-      formats = PERIOD_FORMATS.fetch(period)
-
-      if ActiveRecordAdapter.postgresql?(connection)
-        postgres_period_expression(period, column, formats)
-      elsif ActiveRecordAdapter.mysql?(connection)
-        "DATE_FORMAT(#{column}, #{connection.quote(formats.fetch(:mysql))})"
-      else
-        ActiveRecordAdapter.ensure_supported!(connection)
-      end
-    end
-
-    def postgres_period_expression(period, column, formats)
-      "TO_CHAR(" \
-        "DATE_TRUNC(#{connection.quote(period.to_s)}, #{column}), " \
-        "#{connection.quote(formats.fetch(:postgres))}" \
-        ")"
-    end
-
-    def validated_period(period)
-      normalized_period = period.respond_to?(:to_sym) ? period.to_sym : nil
-      return normalized_period if PERIOD_FORMATS.key?(normalized_period)
-
-      raise ArgumentError, "invalid period: #{period.inspect}"
-    end
-
-    def period_column_expression(column)
-      column = column.to_s
-      return "#{quoted_table_name}.#{connection.quote_column_name(column)}" if column_names.include?(column)
-
-      raise ArgumentError, "invalid period column: #{column.inspect}"
-    end
-  end
-end

data/lib/llm_cost_tracker/period_total.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-
-module LlmCostTracker
-  class PeriodTotal < ActiveRecord::Base
-    self.table_name = "llm_cost_tracker_period_totals"
-  end
-end

data/lib/llm_cost_tracker/price_freshness.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module LlmCostTracker
-  module PriceFreshness
-    STALE_AFTER_DAYS = 30
-
-    class << self
-      def call(metadata, today: Date.today)
-        updated_at = metadata["updated_at"] || metadata[:updated_at]
-        return missing unless updated_at
-
-        date = Date.iso8601(updated_at.to_s)
-        age_days = (today - date).to_i
-        return stale(updated_at) if age_days > STALE_AFTER_DAYS
-
-        [:ok, "updated_at=#{updated_at}"]
-      rescue Date::Error
-        [:warn, "metadata.updated_at=#{updated_at.inspect} is invalid; run bin/rails llm_cost_tracker:prices:refresh"]
-      end
-
-      private
-
-      def missing
-        [:warn, "metadata.updated_at missing; run bin/rails llm_cost_tracker:prices:refresh"]
-      end
-
-      def stale(updated_at)
-        [
-          :warn,
-          "updated_at=#{updated_at} is older than #{STALE_AFTER_DAYS} days; " \
-          "run bin/rails llm_cost_tracker:prices:refresh"
-        ]
-      end
-    end
-  end
-end

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