llm_cost_tracker 0.6.1 → 0.7.1

data/lib/llm_cost_tracker/event_metadata.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module EventMetadata
-    INTERNAL_TAG_KEYS = %w[
-      cache_read_input_tokens
-      cache_write_input_tokens
-      hidden_output_tokens
-      input_tokens
-      output_tokens
-      pricing_mode
-      provider_response_id
-      total_tokens
-    ].freeze
-
-    class << self
-      def usage_data(input_tokens, output_tokens, metadata)
-        metadata = metadata.to_h.symbolize_keys
-        cache_read = first_integer(metadata, :cache_read_input_tokens)
-        cache_write = first_integer(metadata, :cache_write_input_tokens)
-        hidden_output = first_integer(metadata, :hidden_output_tokens)
-        breakdown = UsageBreakdown.build(
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          cache_read_input_tokens: cache_read,
-          cache_write_input_tokens: cache_write,
-          hidden_output_tokens: hidden_output
-        )
-
-        breakdown.to_h.merge(pricing_mode: normalized_pricing_mode(metadata[:pricing_mode])).compact
-      end
-
-      def tags(metadata)
-        metadata.reject { |key, _value| INTERNAL_TAG_KEYS.include?(key.to_s) }
-      end
-
-      private
-
-      def first_integer(metadata, *keys)
-        keys.each { |key| return metadata[key].to_i unless metadata[key].nil? }
-        0
-      end
-
-      def normalized_pricing_mode(value)
-        return nil if value.nil?
-
-        mode = value.to_s.strip
-        mode.empty? || mode == "standard" ? nil : mode
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_usage_breakdown_generator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module LlmCostTracker
-  module Generators
-    class AddUsageBreakdownGenerator < Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Creates a migration to add usage and cost breakdown columns to llm_api_calls"
-
-      def create_migration_file
-        migration_template(
-          "add_usage_breakdown_to_llm_api_calls.rb.erb",
-          "db/migrate/add_usage_breakdown_to_llm_api_calls.rb"
-        )
-      end
-
-      private
-
-      def migration_version
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_usage_breakdown_to_llm_api_calls.rb.erb

@@ -1,29 +0,0 @@
-class AddUsageBreakdownToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def up
-    unless column_exists?(:llm_api_calls, :cache_read_input_tokens)
-      add_column :llm_api_calls, :cache_read_input_tokens, :integer, null: false, default: 0
-    end
-    unless column_exists?(:llm_api_calls, :cache_write_input_tokens)
-      add_column :llm_api_calls, :cache_write_input_tokens, :integer, null: false, default: 0
-    end
-    unless column_exists?(:llm_api_calls, :hidden_output_tokens)
-      add_column :llm_api_calls, :hidden_output_tokens, :integer, null: false, default: 0
-    end
-    unless column_exists?(:llm_api_calls, :cache_read_input_cost)
-      add_column :llm_api_calls, :cache_read_input_cost, :decimal, precision: 20, scale: 8
-    end
-    unless column_exists?(:llm_api_calls, :cache_write_input_cost)
-      add_column :llm_api_calls, :cache_write_input_cost, :decimal, precision: 20, scale: 8
-    end
-    add_column :llm_api_calls, :pricing_mode, :string unless column_exists?(:llm_api_calls, :pricing_mode)
-  end
-
-  def down
-    remove_column :llm_api_calls, :pricing_mode if column_exists?(:llm_api_calls, :pricing_mode)
-    remove_column :llm_api_calls, :cache_write_input_cost if column_exists?(:llm_api_calls, :cache_write_input_cost)
-    remove_column :llm_api_calls, :cache_read_input_cost if column_exists?(:llm_api_calls, :cache_read_input_cost)
-    remove_column :llm_api_calls, :hidden_output_tokens if column_exists?(:llm_api_calls, :hidden_output_tokens)
-    remove_column :llm_api_calls, :cache_write_input_tokens if column_exists?(:llm_api_calls, :cache_write_input_tokens)
-    remove_column :llm_api_calls, :cache_read_input_tokens if column_exists?(:llm_api_calls, :cache_read_input_tokens)
-  end
-end

data/lib/llm_cost_tracker/inbox_event.rb

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

data/lib/llm_cost_tracker/ingestor_lease.rb

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

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,73 +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)
-    def self.install! = Registry.install!
-    def self.checks = Registry.checks
-  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,69 +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",
-        sqlite: "%Y-%m-%d"
-      },
-      month: {
-        postgres: "YYYY-MM",
-        mysql: "%Y-%m",
-        sqlite: "%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
-        "strftime(#{connection.quote(formats.fetch(:sqlite))}, #{column})"
-      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