llm_cost_tracker 0.7.3 → 0.8.0

data/app/models/llm_cost_tracker/ledger/call_metrics.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "llm_cost_tracker/ledger/tags/sql"
-
-module LlmCostTracker
-  module Ledger
-    module CallMetrics
-      def total_cost
-        sum(:total_cost).to_f
-      end
-
-      def total_tokens
-        sum(:total_tokens).to_i
-      end
-
-      def cost_by_model(limit: nil)
-        cost_by_column(:model, limit: limit)
-      end
-
-      def cost_by_provider(limit: nil)
-        cost_by_column(:provider, limit: limit)
-      end
-
-      def group_by_tag(key)
-        group(Arel.sql(tag_value_expression(key)))
-      end
-
-      def cost_by_tag(key, limit: nil)
-        expression = tag_value_expression(key)
-        label_expression = "COALESCE(NULLIF(#{expression}, ''), #{connection.quote('(untagged)')})"
-        relation = select("#{label_expression} AS name, COALESCE(SUM(total_cost), 0) AS total_cost")
-                   .group(Arel.sql(label_expression))
-                   .order(Arel.sql("COALESCE(SUM(total_cost), 0) DESC"))
-        relation = relation.limit(limit) if limit
-        relation
-      end
-
-      def average_latency_ms
-        average(:latency_ms)&.to_f
-      end
-
-      def latency_by_model
-        group(:model).average(:latency_ms).transform_values(&:to_f)
-      end
-
-      def latency_by_provider
-        group(:provider).average(:latency_ms).transform_values(&:to_f)
-      end
-
-      def tag_value_expression(key, table_name: quoted_table_name)
-        Ledger::Tags::Sql.value_expression(key, table_name: table_name)
-      end
-
-      private
-
-      def cost_by_column(column, limit:)
-        quoted_column = "#{quoted_table_name}.#{connection.quote_column_name(column)}"
-        relation = select("#{quoted_column} AS name, COALESCE(SUM(total_cost), 0) AS total_cost")
-                   .group(column)
-                   .order(Arel.sql("COALESCE(SUM(total_cost), 0) DESC"))
-        relation = relation.limit(limit) if limit
-        relation
-      end
-    end
-  end
-end

data/app/models/llm_cost_tracker/ledger/period/grouping.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "llm_cost_tracker/ledger/schema/adapter"
-
-module LlmCostTracker
-  module Ledger
-    module Period
-      module Grouping
-        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 Ledger::Schema::Adapter.postgresql?(connection)
-            postgres_period_expression(period, column, formats)
-          elsif Ledger::Schema::Adapter.mysql?(connection)
-            "DATE_FORMAT(#{column}, #{connection.quote(formats.fetch(:mysql))})"
-          else
-            Ledger::Schema::Adapter.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.try(:to_sym)
-          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
-  end
-end

data/app/models/llm_cost_tracker/ledger/period/total.rb

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

data/app/models/llm_cost_tracker/ledger/tags/accessors.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module LlmCostTracker
-  module Ledger
-    module Tags
-      module Accessors
-        def parsed_tags
-          return tags.transform_keys(&:to_s) if tags.is_a?(Hash)
-
-          JSON.parse(tags || "{}")
-        rescue JSON::ParserError
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/configuration/instrumentation.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module ConfigurationInstrumentation
-    def instrument(*names)
-      ensure_shared_configuration_mutable!
-      @instrumented_integrations = (@instrumented_integrations + normalize_instrumentation_names(names)).uniq
-    end
-
-    def instrumented?(name)
-      @instrumented_integrations.include?(name.to_sym)
-    end
-
-    private
-
-    def normalize_instrumentation_names(names)
-      names.flatten.flat_map do |name|
-        key = name.to_sym
-        next Integrations.names if key == :all
-
-        validate_instrumentation_name!(key)
-        key
-      end
-    end
-
-    def validate_instrumentation_name!(name)
-      return if Integrations.names.include?(name)
-
-      raise Error, "Unknown integration: #{name.inspect}. " \
-                   "Use one of: #{Integrations.names.join(', ')}"
-    end
-  end
-end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_ingestion_generator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module LlmCostTracker
-  module Generators
-    class AddIngestionGenerator < Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Creates a migration to add durable ActiveRecord ingestion"
-
-      def create_migration_file
-        migration_template(
-          "add_ingestion_to_llm_cost_tracker.rb.erb",
-          "db/migrate/add_ingestion_to_llm_cost_tracker.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/add_latency_ms_generator.rb

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

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

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module LlmCostTracker
-  module Generators
-    class AddStreamingGenerator < Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Creates a migration to add llm_api_calls.stream and llm_api_calls.usage_source"
-
-      def create_migration_file
-        migration_template(
-          "add_streaming_to_llm_api_calls.rb.erb",
-          "db/migrate/add_streaming_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/add_token_usage_generator.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module LlmCostTracker
-  module Generators
-    class AddTokenUsageGenerator < Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-
-      TOKEN_COLUMNS = %w[
-        cache_read_input_tokens
-        cache_write_input_tokens
-        cache_write_1h_input_tokens
-        hidden_output_tokens
-      ].freeze
-      COST_COLUMNS = %w[
-        cache_read_input_cost
-        cache_write_input_cost
-        cache_write_1h_input_cost
-      ].freeze
-      COLUMN_NAMES = (TOKEN_COLUMNS + COST_COLUMNS + %w[pricing_mode]).freeze
-
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Creates a migration to add token usage and token cost columns to llm_api_calls"
-
-      def create_migration_file
-        migration_template(
-          "add_token_usage_to_llm_api_calls.rb.erb",
-          "db/migrate/add_token_usage_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_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