llm_cost_tracker 0.7.2 → 0.8.0

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

@@ -1,33 +0,0 @@
-class AddIngestionToLlmCostTracker < ActiveRecord::Migration<%= migration_version %>
-  def change
-    add_column :llm_api_calls, :event_id, :string unless column_exists?(:llm_api_calls, :event_id)
-    add_index :llm_api_calls, :event_id, unique: true if column_exists?(:llm_api_calls, :event_id) &&
-                                                         !index_exists?(:llm_api_calls, :event_id)
-
-    create_table :llm_cost_tracker_inbox_events do |t|
-      t.string   :event_id, null: false
-      t.decimal  :total_cost, precision: 20, scale: 8
-      t.datetime :tracked_at, null: false
-      t.text     :payload, null: false
-      t.datetime :locked_at
-      t.string   :locked_by
-      t.integer  :attempts, null: false, default: 0
-      t.text     :last_error
-
-      t.timestamps
-    end unless table_exists?(:llm_cost_tracker_inbox_events)
-
-    create_table :llm_cost_tracker_ingestor_leases do |t|
-      t.string   :name, null: false
-      t.string   :locked_by
-      t.datetime :locked_until
-
-      t.timestamps
-    end unless table_exists?(:llm_cost_tracker_ingestor_leases)
-
-    add_index :llm_cost_tracker_inbox_events, :event_id, unique: true unless index_exists?(:llm_cost_tracker_inbox_events, :event_id)
-    add_index :llm_cost_tracker_inbox_events, :tracked_at unless index_exists?(:llm_cost_tracker_inbox_events, :tracked_at)
-    add_index :llm_cost_tracker_inbox_events, [:locked_at, :id] unless index_exists?(:llm_cost_tracker_inbox_events, [:locked_at, :id])
-    add_index :llm_cost_tracker_ingestor_leases, :name, unique: true unless index_exists?(:llm_cost_tracker_ingestor_leases, :name)
-  end
-end

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

@@ -1,9 +0,0 @@
-class AddLatencyMsToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def up
-    add_column :llm_api_calls, :latency_ms, :integer unless column_exists?(:llm_api_calls, :latency_ms)
-  end
-
-  def down
-    remove_column :llm_api_calls, :latency_ms if column_exists?(:llm_api_calls, :latency_ms)
-  end
-end

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

@@ -1,104 +0,0 @@
-require "llm_cost_tracker/ledger/schema/adapter"
-
-class AddPeriodTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_version %>
-  def up
-    create_table :llm_cost_tracker_period_totals do |t|
-      t.string :period, null: false
-      t.date :period_start, null: false
-      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
-
-      t.timestamps
-    end unless table_exists?(:llm_cost_tracker_period_totals)
-
-    backfill_period_totals
-
-    add_index :llm_cost_tracker_period_totals, [:period, :period_start],
-              unique: true unless index_exists?(:llm_cost_tracker_period_totals, [:period, :period_start])
-  end
-
-  def down
-    remove_index :llm_cost_tracker_period_totals, [:period, :period_start] if index_exists?(:llm_cost_tracker_period_totals, [:period, :period_start])
-    drop_table :llm_cost_tracker_period_totals if table_exists?(:llm_cost_tracker_period_totals)
-  end
-
-  private
-
-  def backfill_period_totals
-    backfill_legacy_monthly_totals if table_exists?(:llm_cost_tracker_monthly_totals)
-    return unless table_exists?(:llm_api_calls)
-
-    backfill_period_total("day", day_bucket_sql)
-    backfill_period_total("month", month_bucket_sql)
-  end
-
-  def backfill_legacy_monthly_totals
-    execute <<~SQL
-      INSERT INTO llm_cost_tracker_period_totals (period, period_start, total_cost, created_at, updated_at)
-      SELECT #{connection.quote("month")} AS period,
-             month AS period_start,
-             total_cost,
-             CURRENT_TIMESTAMP,
-             CURRENT_TIMESTAMP
-      FROM llm_cost_tracker_monthly_totals legacy
-      WHERE NOT EXISTS (
-        SELECT 1
-        FROM llm_cost_tracker_period_totals existing
-        WHERE existing.period = #{connection.quote("month")}
-          AND existing.period_start = legacy.month
-      )
-    SQL
-  end
-
-  def backfill_period_total(period, bucket_sql)
-    execute <<~SQL
-      INSERT INTO llm_cost_tracker_period_totals (period, period_start, total_cost, created_at, updated_at)
-      SELECT aggregated.period,
-             aggregated.period_start,
-             aggregated.total_cost,
-             CURRENT_TIMESTAMP,
-             CURRENT_TIMESTAMP
-      FROM (
-        SELECT #{connection.quote(period)} AS period,
-               #{bucket_sql} AS period_start,
-               SUM(total_cost) AS total_cost
-        FROM llm_api_calls
-        WHERE total_cost IS NOT NULL
-        GROUP BY #{bucket_sql}
-      ) aggregated
-      WHERE NOT EXISTS (
-        SELECT 1
-        FROM llm_cost_tracker_period_totals existing
-        WHERE existing.period = aggregated.period
-          AND existing.period_start = aggregated.period_start
-      )
-    SQL
-  end
-
-  def day_bucket_sql
-    if postgresql?
-      "DATE_TRUNC('day', tracked_at)::date"
-    elsif mysql?
-      "DATE(tracked_at)"
-    else
-      raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
-    end
-  end
-
-  def month_bucket_sql
-    if postgresql?
-      "DATE_TRUNC('month', tracked_at)::date"
-    elsif mysql?
-      "DATE_FORMAT(tracked_at, '%Y-%m-01')"
-    else
-      raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
-    end
-  end
-
-  def postgresql?
-    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
-  end
-
-  def mysql?
-    LlmCostTracker::Ledger::Schema::Adapter.mysql?(connection)
-  end
-end

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

@@ -1,15 +0,0 @@
-class AddProviderResponseIdToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def up
-    return if column_exists?(:llm_api_calls, :provider_response_id)
-
-    add_column :llm_api_calls, :provider_response_id, :string
-    add_index :llm_api_calls, :provider_response_id
-  end
-
-  def down
-    return unless column_exists?(:llm_api_calls, :provider_response_id)
-
-    remove_index :llm_api_calls, :provider_response_id if index_exists?(:llm_api_calls, :provider_response_id)
-    remove_column :llm_api_calls, :provider_response_id
-  end
-end

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

@@ -1,21 +0,0 @@
-class AddStreamingToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def up
-    unless column_exists?(:llm_api_calls, :stream)
-      add_column :llm_api_calls, :stream, :boolean, null: false, default: false
-    end
-
-    unless column_exists?(:llm_api_calls, :usage_source)
-      add_column :llm_api_calls, :usage_source, :string
-    end
-  end
-
-  def down
-    if column_exists?(:llm_api_calls, :usage_source)
-      remove_column :llm_api_calls, :usage_source
-    end
-
-    if column_exists?(:llm_api_calls, :stream)
-      remove_column :llm_api_calls, :stream
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-class AddTokenUsageToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def up
-<% LlmCostTracker::Generators::AddTokenUsageGenerator::TOKEN_COLUMNS.each do |column| -%>
-    unless column_exists?(:llm_api_calls, :<%= column %>)
-      add_column :llm_api_calls, :<%= column %>, :integer, null: false, default: 0
-    end
-<% end -%>
-<% LlmCostTracker::Generators::AddTokenUsageGenerator::COST_COLUMNS.each do |column| -%>
-    unless column_exists?(:llm_api_calls, :<%= column %>)
-      add_column :llm_api_calls, :<%= column %>, :decimal, precision: 20, scale: 8
-    end
-<% 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)
-<% (LlmCostTracker::Generators::AddTokenUsageGenerator::COST_COLUMNS + LlmCostTracker::Generators::AddTokenUsageGenerator::TOKEN_COLUMNS).reverse.each do |column| -%>
-    remove_column :llm_api_calls, :<%= column %> if column_exists?(:llm_api_calls, :<%= column %>)
-<% end -%>
-  end
-end

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

@@ -1,83 +0,0 @@
-require "llm_cost_tracker/ledger/schema/adapter"
-
-class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
-  def change
-    create_table :llm_api_calls do |t|
-      t.string  :event_id,      null: false
-      t.string  :provider,      null: false
-      t.string  :model,         null: false
-<% LlmCostTracker::TokenUsage::STORED_KEYS.each do |column| -%>
-      t.integer :<%= column %>, null: false, default: 0
-<% end -%>
-<% LlmCostTracker::Pricing::COST_KEYS.each do |column| -%>
-      t.decimal :<%= column %>, precision: 20, scale: 8
-<% end -%>
-      t.integer :latency_ms
-      t.boolean :stream,        null: false, default: false
-      t.string  :usage_source
-      t.string  :provider_response_id
-      t.string  :pricing_mode
-      if postgresql?
-        t.jsonb :tags, null: false, default: {}
-      elsif mysql?
-        t.json :tags, null: false
-      else
-        raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
-      end
-      t.datetime :tracked_at,   null: false
-
-      t.timestamps
-    end
-
-    create_table :llm_cost_tracker_period_totals do |t|
-      t.string :period, null: false
-      t.date :period_start, null: false
-      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
-
-      t.timestamps
-    end
-
-    create_table :llm_cost_tracker_inbox_events do |t|
-      t.string   :event_id, null: false
-      t.decimal  :total_cost, precision: 20, scale: 8
-      t.datetime :tracked_at, null: false
-      t.text     :payload, null: false
-      t.datetime :locked_at
-      t.string   :locked_by
-      t.integer  :attempts, null: false, default: 0
-      t.text     :last_error
-
-      t.timestamps
-    end
-
-    create_table :llm_cost_tracker_ingestor_leases do |t|
-      t.string   :name, null: false
-      t.string   :locked_by
-      t.datetime :locked_until
-
-      t.timestamps
-    end
-
-    add_index :llm_api_calls, :event_id, unique: true
-    add_index :llm_api_calls, :tracked_at
-    add_index :llm_api_calls, [:provider, :tracked_at]
-    add_index :llm_api_calls, [:model, :tracked_at]
-    add_index :llm_api_calls, :provider_response_id
-    add_index :llm_api_calls, :tags, using: :gin if postgresql?
-    add_index :llm_cost_tracker_period_totals, [:period, :period_start], unique: true
-    add_index :llm_cost_tracker_inbox_events, :event_id, unique: true
-    add_index :llm_cost_tracker_inbox_events, :tracked_at
-    add_index :llm_cost_tracker_inbox_events, [:locked_at, :id]
-    add_index :llm_cost_tracker_ingestor_leases, :name, unique: true
-  end
-
-  private
-
-  def postgresql?
-    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
-  end
-
-  def mysql?
-    LlmCostTracker::Ledger::Schema::Adapter.mysql?(connection)
-  end
-end

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

@@ -1,26 +0,0 @@
-class UpgradeLlmApiCallCostPrecision < ActiveRecord::Migration<%= migration_version %>
-  COST_COLUMNS = %i[
-    input_cost
-    cache_read_input_cost
-    cache_write_input_cost
-    cache_write_1h_input_cost
-    output_cost
-    total_cost
-  ].freeze
-
-  def up
-    COST_COLUMNS.each do |column|
-      next unless column_exists?(:llm_api_calls, column)
-
-      change_column :llm_api_calls, column, :decimal, precision: 20, scale: 8
-    end
-  end
-
-  def down
-    COST_COLUMNS.each do |column|
-      next unless column_exists?(:llm_api_calls, column)
-
-      change_column :llm_api_calls, column, :decimal, precision: 12, scale: 8
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require "llm_cost_tracker/ledger/schema/adapter"
-
-class UpgradeLlmApiCallTagsToJsonb < ActiveRecord::Migration<%= migration_version %>
-  def up
-    unless postgresql?
-      say "Skipping llm_api_calls.tags JSONB upgrade: database adapter is #{connection.adapter_name}."
-      return
-    end
-
-    return if tags_jsonb?
-
-    remove_index :llm_api_calls, :tags if index_exists?(:llm_api_calls, :tags)
-    say "Upgrading llm_api_calls.tags to jsonb rewrites the table on PostgreSQL. Run this migration during a maintenance window on large datasets."
-
-    change_column(
-      :llm_api_calls,
-      :tags,
-      :jsonb,
-      using: "CASE WHEN tags IS NULL OR tags = '' THEN '{}'::jsonb ELSE tags::jsonb END",
-      default: {},
-      null: false
-    )
-
-    add_index :llm_api_calls, :tags, using: :gin unless index_exists?(:llm_api_calls, :tags)
-  end
-
-  def down
-    return unless postgresql?
-
-    remove_index :llm_api_calls, :tags if index_exists?(:llm_api_calls, :tags)
-    change_column :llm_api_calls, :tags, :text, using: "tags::text"
-  end
-
-  private
-
-  def postgresql?
-    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
-  end
-
-  def tags_jsonb?
-    column = connection.columns(:llm_api_calls).find { |candidate| candidate.name == "tags" }
-    column&.sql_type.to_s.downcase == "jsonb"
-  end
-end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/upgrade_cost_precision_generator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module LlmCostTracker
-  module Generators
-    class UpgradeCostPrecisionGenerator < Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Creates a migration to widen llm_api_calls cost decimal precision"
-
-      def create_migration_file
-        migration_template(
-          "upgrade_llm_api_call_cost_precision.rb.erb",
-          "db/migrate/upgrade_llm_api_call_cost_precision.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/upgrade_tags_to_jsonb_generator.rb

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

data/lib/llm_cost_tracker/ledger/rollups/batch.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-require_relative "../period"
-
-module LlmCostTracker
-  module Ledger
-    class Rollups
-      class Batch
-        def self.rows(events)
-          new(events).rows
-        end
-
-        def initialize(events)
-          @events = events
-        end
-
-        def rows
-          totals.map do |(period, period_start), total_cost|
-            {
-              period: period,
-              period_start: period_start,
-              total_cost: total_cost
-            }
-          end
-        end
-
-        private
-
-        attr_reader :events
-
-        def totals
-          events.each_with_object(Hash.new { |hash, key| hash[key] = BigDecimal("0") }) do |event, rows|
-            Period::PERIODS.each do |period, name|
-              rows[[name, Period.bucket(period, event.tracked_at)]] += BigDecimal(event.total_cost.to_s)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/ledger/schema/period_totals.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Ledger
-    module Schema
-      module PeriodTotals
-        REQUIRED_COLUMNS = %w[period period_start total_cost].freeze
-        UNIQUE_COLUMNS = %i[period period_start].freeze
-
-        class << self
-          def current_schema_errors
-            connection = Ledger::Call.connection
-            table_name = Ledger::Period::Total.table_name
-            return ["llm_cost_tracker_period_totals table is missing"] unless connection.data_source_exists?(table_name)
-
-            errors = []
-            missing = REQUIRED_COLUMNS - Ledger::Period::Total.columns_hash.keys
-            errors << "missing columns: #{missing.join(', ')}" if missing.any?
-            errors << "missing unique index: period, period_start" unless unique_period_index?(connection, table_name)
-            errors
-          end
-
-          private
-
-          def unique_period_index?(connection, table_name)
-            connection.index_exists?(table_name, UNIQUE_COLUMNS, unique: true)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/pricing/components.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Pricing
-    Component = Data.define(:price_key, :token_key, :cost_key)
-
-    COMPONENTS = [
-      Component.new(
-        price_key: :input,
-        token_key: :input_tokens,
-        cost_key: :input_cost
-      ),
-      Component.new(
-        price_key: :cache_read_input,
-        token_key: :cache_read_input_tokens,
-        cost_key: :cache_read_input_cost
-      ),
-      Component.new(
-        price_key: :cache_write_input,
-        token_key: :cache_write_input_tokens,
-        cost_key: :cache_write_input_cost
-      ),
-      Component.new(
-        price_key: :cache_write_1h_input,
-        token_key: :cache_write_1h_input_tokens,
-        cost_key: :cache_write_1h_input_cost
-      ),
-      Component.new(
-        price_key: :output,
-        token_key: :output_tokens,
-        cost_key: :output_cost
-      )
-    ].freeze
-
-    COST_KEYS = (COMPONENTS.map(&:cost_key) + %i[total_cost]).freeze
-  end
-end

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "yaml"
-
-require_relative "../registry"
-
-module LlmCostTracker
-  module Pricing
-    module Sync
-      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) > Registry::MAX_FILE_BYTES
-            raise ArgumentError, "pricing registry exceeds #{Registry::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
-end