llm_cost_tracker 0.7.3 → 0.8.0

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -15,7 +15,8 @@ module LlmCostTracker
     include TokenUsageHelper
 
     def coverage_percent(numerator, denominator)
-      return 0.0 unless denominator.to_i.positive?
+      denominator = denominator.to_f
+      return 0.0 unless denominator.positive?
 
       (numerator.to_f / denominator) * 100.0
     end
@@ -39,16 +40,19 @@ module LlmCostTracker
       number_with_delimiter(value.to_i)
     end
 
-    def format_tokens(value)
-      number(value)
-    end
-
     def format_date(value)
       value.try(:strftime, "%Y-%m-%d %H:%M") || value.to_s
     end
 
     def pricing_status(call)
-      call.total_cost.nil? ? "Unknown pricing" : "Estimated"
+      return "Unknown pricing" if call.total_cost.nil?
+      return "Estimated" unless call.has_attribute?(:cost_status)
+
+      {
+        LlmCostTracker::Billing::CostStatus::COMPLETE => "Estimated",
+        LlmCostTracker::Billing::CostStatus::FREE => "Free",
+        LlmCostTracker::Billing::CostStatus::PARTIAL => "Partial pricing"
+      }.fetch(call.cost_status, "Unknown pricing")
     end
 
     def percent(value)
@@ -100,15 +104,6 @@ module LlmCostTracker
       value.to_s
     end
 
-    def tags_summary(tags, limit: 3)
-      tags = normalized_tags(tags)
-      return "(untagged)" if tags.empty?
-
-      summary = tags.first(limit).map { |key, value| "#{key}=#{tag_value_summary(value)}" }
-      summary << "+#{tags.size - limit}" if tags.size > limit
-      summary.join(", ")
-    end
-
     def tag_chip_entries(tags, limit: 3)
       normalized = normalized_tags(tags)
       return [] if normalized.empty?
@@ -124,14 +119,6 @@ module LlmCostTracker
       truncate_text(safe_json(tags), TAG_TOOLTIP_BYTES)
     end
 
-    def budget_fill_modifier(percent)
-      percent = percent.to_f
-      return "lct-budget-fill--over" if percent >= 100.0
-      return "lct-budget-fill--warn" if percent >= 80.0
-
-      ""
-    end
-
     def current_query(overrides = {})
       request.query_parameters.symbolize_keys.merge(overrides)
     end
@@ -164,7 +151,7 @@ module LlmCostTracker
     def truncate_text(string, limit)
       return string if string.bytesize <= limit
 
-      "#{string.byteslice(0, limit).to_s.encode('UTF-8', invalid: :replace, undef: :replace)}..."
+      "#{string.byteslice(0, limit).encode('UTF-8', invalid: :replace, undef: :replace)}..."
     end
   end
 end

data/app/helpers/llm_cost_tracker/dashboard_filter_helper.rb

@@ -2,7 +2,7 @@
 
 module LlmCostTracker
   module DashboardFilterHelper
-    FILTER_PARAM_KEYS = %i[from to provider model stream usage_source tag sort page per].freeze
+    FILTER_PARAM_KEYS = %i[from to provider model stream usage_source tag].freeze
 
     STREAM_FILTER_OPTIONS = [
       ["Streaming only", "yes"],
@@ -14,33 +14,15 @@ module LlmCostTracker
     end
 
     def active_tag_filters
-      tag_params = LlmCostTracker::Dashboard::Params.to_hash(params[:tag]).transform_keys(&:to_s).transform_values(&:to_s)
+      tag_params = LlmCostTracker::Dashboard::Params.tag_query(params[:tag])
 
       tag_params.filter_map do |key, value|
-        next if key.blank? || value.blank?
-
         {
           label: "Tag",
           value: "#{key}=#{value}",
-          path: dashboard_filter_path(current_query(tag: tag_params.except(key.to_s).presence, page: nil))
+          path: dashboard_filter_path(current_query(tag: tag_params.except(key).presence, page: nil))
         }
       end
     end
-
-    def dashboard_date_range_label(from, to)
-      from_label = short_date_label(from) || "Any time"
-      to_label = short_date_label(to) || "Now"
-      "#{from_label} - #{to_label}"
-    end
-
-    private
-
-    def short_date_label(value)
-      return nil if value.blank?
-
-      Date.iso8601(value.to_s).strftime("%b %-d, %Y")
-    rescue ArgumentError
-      value.to_s
-    end
   end
 end

data/app/helpers/llm_cost_tracker/dashboard_filter_options_helper.rb

@@ -15,14 +15,14 @@ module LlmCostTracker
     private
 
     def filter_options_for(column, filter_params:)
-      source = LlmCostTracker::Dashboard::Params.to_hash(filter_params)
-      scope_params = source.stringify_keys.merge(
-        column.to_s => nil, "format" => nil, "page" => nil, "per" => nil, "sort" => nil
+      source = LlmCostTracker::Dashboard::Params.to_hash(filter_params).symbolize_keys
+      scope_params = source.merge(
+        column => nil, format: nil, page: nil, per: nil, sort: nil
       )
       values = LlmCostTracker::Dashboard::Filter.call(params: scope_params)
                                                 .where.not(column => [nil, ""])
                                                 .distinct.order(column).limit(MAX_FILTER_OPTIONS).pluck(column)
-      current = source[column.to_s].presence || source[column].presence
+      current = source[column].presence
       values.unshift(current) if current && !values.include?(current)
       values
     end

data/app/helpers/llm_cost_tracker/dashboard_query_helper.rb

@@ -11,7 +11,7 @@ module LlmCostTracker
 
     def calls_query_for_tag(key:, value:)
       query = current_query(page: nil, per: nil, format: nil)
-      tags = LlmCostTracker::Dashboard::Params.to_hash(query[:tag]).transform_keys(&:to_s).transform_values(&:to_s)
+      tags = LlmCostTracker::Dashboard::Params.tag_query(query[:tag])
       query[:tag] = tags.merge(key.to_s => value.to_s)
       query
     end

data/app/helpers/llm_cost_tracker/token_usage_helper.rb

@@ -6,22 +6,26 @@ module LlmCostTracker
       input_tokens: "Input",
       cache_read_input_tokens: "Cache read",
       cache_write_input_tokens: "Cache write",
-      cache_write_1h_input_tokens: "1h cache write",
+      cache_write_extended_input_tokens: "Extended cache write",
+      audio_input_tokens: "Audio input",
       output_tokens: "Output",
+      audio_output_tokens: "Audio output",
       hidden_output_tokens: "Hidden output"
     }.freeze
     QUALITY_LABELS = COMPONENT_LABELS.merge(
       input_tokens: "Regular input",
       cache_read_input_tokens: "Cache read input",
       cache_write_input_tokens: "Cache write input",
-      cache_write_1h_input_tokens: "1h cache write input"
+      cache_write_extended_input_tokens: "Extended cache write input"
     ).freeze
     STACK_CLASSES = {
       input_tokens: "lct-stack-fill-input",
       cache_read_input_tokens: "lct-stack-fill-cache-read",
       cache_write_input_tokens: "lct-stack-fill-cache-write",
-      cache_write_1h_input_tokens: "lct-stack-fill-cache-write-1h",
-      output_tokens: "lct-stack-fill-output"
+      cache_write_extended_input_tokens: "lct-stack-fill-cache-write-extended",
+      audio_input_tokens: "lct-stack-fill-audio-input",
+      output_tokens: "lct-stack-fill-output",
+      audio_output_tokens: "lct-stack-fill-audio-output"
     }.freeze
 
     def token_usage_stack_components
@@ -30,18 +34,26 @@ module LlmCostTracker
       end
     end
 
-    def token_usage_quality_label(token_key)
-      QUALITY_LABELS.fetch(token_key.to_sym)
+    def call_line_item_costs_by_component(call)
+      call.line_items.each_with_object({}) do |line_item, accumulator|
+        component = LlmCostTracker::Billing::Components::TOKEN_PRICED.find do |item|
+          item.kind.to_s == line_item.kind.to_s &&
+            item.direction.to_s == line_item.direction.to_s &&
+            item.cache_state.to_s == line_item.cache_state.to_s
+        end
+        accumulator[component.key] = line_item.cost if component && line_item.cost
+      end
     end
 
     private
 
     def token_usage_display_components(labels:)
-      LlmCostTracker::Pricing::COMPONENTS.map do |component|
+      LlmCostTracker::Billing::Components::TOKEN_PRICED.map do |component|
         token_key = component.token_key
         {
           token_key: token_key,
           cost_key: component.cost_key,
+          price_key: component.key,
           label: labels.fetch(token_key),
           css_class: STACK_CLASSES[token_key]
         }
@@ -49,6 +61,7 @@ module LlmCostTracker
         {
           token_key: :hidden_output_tokens,
           cost_key: nil,
+          price_key: nil,
           label: labels.fetch(:hidden_output_tokens),
           css_class: nil
         }

data/app/models/llm_cost_tracker/call.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "securerandom"
+
+require "llm_cost_tracker/billing/cost_status"
+require "llm_cost_tracker/ledger/schema/adapter"
+require "llm_cost_tracker/ledger/tags/sql"
+
+module LlmCostTracker
+  class Call < ActiveRecord::Base
+    self.table_name = "llm_cost_tracker_calls"
+
+    before_validation :assign_event_id
+
+    PERIOD_FORMATS = {
+      day: {
+        postgres: "YYYY-MM-DD",
+        mysql: "%Y-%m-%d"
+      },
+      month: {
+        postgres: "YYYY-MM",
+        mysql: "%Y-%m"
+      }
+    }.freeze
+
+    private_constant :PERIOD_FORMATS
+
+    scope :with_cost, -> { where.not(total_cost: nil) }
+    scope :without_cost, -> { where(total_cost: nil) }
+    scope :unknown_pricing, lambda {
+      where(total_cost: nil).or(
+        where(cost_status: [Billing::CostStatus::UNKNOWN, Billing::CostStatus::PARTIAL])
+      )
+    }
+    scope :with_latency, -> { where.not(latency_ms: nil) }
+    scope :streaming,     -> { where(stream: true) }
+    scope :non_streaming, -> { where(stream: [false, nil]) }
+    scope :by_usage_source, ->(source) { where(usage_source: source.to_s) }
+    scope :with_provider_response_id, -> { where.not(provider_response_id: [nil, ""]) }
+    scope :missing_provider_response_id, -> { where(provider_response_id: [nil, ""]) }
+    scope :streaming_missing_usage, lambda {
+      where(stream: true).where(usage_source: ["unknown", nil])
+    }
+
+    has_many :line_items,
+             class_name: "LlmCostTracker::CallLineItem",
+             foreign_key: :llm_cost_tracker_call_id,
+             inverse_of: :call,
+             dependent: :delete_all
+
+    has_many :tag_records,
+             class_name: "LlmCostTracker::CallTag",
+             foreign_key: :llm_cost_tracker_call_id,
+             inverse_of: :call,
+             dependent: :delete_all
+
+    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) }
+
+    class << self
+      def by_tag(key, value) = by_tags(key => value)
+
+      def by_tags(tags) = Ledger::Tags::Query.apply(tags)
+
+      def total_cost = sum(:total_cost).to_f
+
+      def total_tokens = sum(:total_tokens).to_i
+
+      def cost_by_model(limit: nil) = cost_by_column(:model, limit: limit)
+
+      def cost_by_provider(limit: nil) = cost_by_column(:provider, limit: limit)
+
+      def group_by_tag(key)
+        Ledger::Tags::Sql.join_relation(self, key).group(Ledger::Tags::Sql.value_arel)
+      end
+
+      def cost_by_tag(key, limit: nil)
+        label = Ledger::Tags::Sql.label_sql(connection)
+        raw_value = Ledger::Tags::Sql.raw_value_sql(connection)
+        relation = Ledger::Tags::Sql.join_relation(self, key)
+                                    .select("#{label} AS name", "COALESCE(SUM(total_cost), 0) AS total_cost")
+                                    .group(Arel.sql(label))
+                                    .order(
+                                      Arel.sql("COALESCE(SUM(total_cost), 0) DESC"),
+                                      Arel.sql("MAX(CASE WHEN #{raw_value} IS NULL THEN 1 ELSE 0 END) ASC"),
+                                      Arel.sql("#{label} DESC")
+                                    )
+        relation = relation.limit(limit) if limit
+        relation
+      end
+
+      def average_latency_ms = average(:latency_ms)&.to_f
+
+      def latency_by_model = group(:model).average(:latency_ms).transform_values(&:to_f)
+
+      def latency_by_provider = group(:provider).average(:latency_ms).transform_values(&:to_f)
+
+      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 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
+
+      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.name)}, #{column}), " \
+          "#{connection.quote(formats.fetch(:postgres))}" \
+          ")"
+      end
+
+      def validated_period(period)
+        return period if PERIOD_FORMATS.key?(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
+
+    def parsed_tags
+      tag_records.to_h do |record|
+        [record.key, record.value]
+      end
+    end
+
+    private
+
+    def assign_event_id
+      self.event_id ||= SecureRandom.uuid
+    end
+  end
+end

data/app/models/llm_cost_tracker/call_line_item.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module LlmCostTracker
+  class CallLineItem < ActiveRecord::Base
+    self.table_name = "llm_cost_tracker_call_line_items"
+
+    belongs_to :call,
+               class_name: "LlmCostTracker::Call",
+               foreign_key: :llm_cost_tracker_call_id,
+               inverse_of: :line_items
+
+    scope :tokens, -> { where("kind LIKE ?", "%_token") }
+    scope :by_kind, ->(kind) { where(kind: kind.to_s) }
+    scope :by_direction, ->(direction) { where(direction: direction.to_s) }
+    scope :by_modality, ->(modality) { where(modality: modality.to_s) }
+    scope :cached, -> { where.not(cache_state: ["none", nil]) }
+    scope :priced, -> { where(cost_status: %w[complete free]) }
+    scope :unpriced, -> { where(cost_status: "unknown") }
+  end
+end

data/app/models/llm_cost_tracker/call_rollup.rb

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

data/app/models/llm_cost_tracker/call_tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module LlmCostTracker
+  class CallTag < ActiveRecord::Base
+    self.table_name = "llm_cost_tracker_call_tags"
+
+    belongs_to :call,
+               class_name: "LlmCostTracker::Call",
+               foreign_key: :llm_cost_tracker_call_id,
+               inverse_of: :tag_records
+
+    scope :with_key, ->(key) { where(key: key.to_s) }
+  end
+end

data/app/models/llm_cost_tracker/ingestion/inbox_entry.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module LlmCostTracker
+  module Ingestion
+    class InboxEntry < ActiveRecord::Base
+      self.table_name = "llm_cost_tracker_ingestion_inbox_entries"
+
+      MAX_ATTEMPTS_BEFORE_QUARANTINE = 5
+    end
+  end
+end

data/app/models/llm_cost_tracker/ingestion/lease.rb

@@ -5,7 +5,7 @@ require "active_record"
 module LlmCostTracker
   module Ingestion
     class Lease < ActiveRecord::Base
-      self.table_name = "llm_cost_tracker_ingestor_leases"
+      self.table_name = "llm_cost_tracker_ingestion_leases"
     end
   end
 end

data/app/models/llm_cost_tracker/provider_invoice.rb

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