llm_cost_tracker 0.3.3 → 0.4.1

data/lib/llm_cost_tracker/tags_column.rb

@@ -2,39 +2,96 @@
 
 module LlmCostTracker
   module TagsColumn
+    USAGE_BREAKDOWN_COLUMNS = %w[
+      cache_read_input_tokens
+      cache_write_input_tokens
+      hidden_output_tokens
+    ].freeze
+
+    USAGE_BREAKDOWN_COST_COLUMNS = %w[
+      cache_read_input_cost
+      cache_write_input_cost
+    ].freeze
+
+    def reset_column_information
+      remove_instance_variable(:@lct_schema_capabilities) if instance_variable_defined?(:@lct_schema_capabilities)
+
+      super
+    end
+
     def tags_json_column?
-      tags_jsonb_column? || tags_mysql_json_column?
+      capabilities = lct_schema_capabilities
+
+      capabilities.fetch(:tags_jsonb) || capabilities.fetch(:tags_mysql_json)
     end
 
     def tags_jsonb_column?
-      column = columns_hash["tags"]
-      return false unless column
-
-      column.type == :jsonb || column.sql_type.to_s.downcase == "jsonb"
+      lct_schema_capabilities.fetch(:tags_jsonb)
     end
 
     def tags_mysql_json_column?
-      column = columns_hash["tags"]
-      return false unless column
-      return false if tags_jsonb_column?
-
-      column.type == :json && connection.adapter_name.match?(/mysql/i)
+      lct_schema_capabilities.fetch(:tags_mysql_json)
     end
 
     def latency_column?
-      columns_hash.key?("latency_ms")
+      lct_schema_capabilities.fetch(:latency)
     end
 
     def stream_column?
-      columns_hash.key?("stream")
+      lct_schema_capabilities.fetch(:stream)
     end
 
     def usage_source_column?
-      columns_hash.key?("usage_source")
+      lct_schema_capabilities.fetch(:usage_source)
     end
 
     def provider_response_id_column?
-      columns_hash.key?("provider_response_id")
+      lct_schema_capabilities.fetch(:provider_response_id)
+    end
+
+    def pricing_mode_column?
+      lct_schema_capabilities.fetch(:pricing_mode)
+    end
+
+    def usage_breakdown_columns?
+      lct_schema_capabilities.fetch(:usage_breakdown)
+    end
+
+    def usage_breakdown_cost_columns?
+      lct_schema_capabilities.fetch(:usage_breakdown_cost)
+    end
+
+    private
+
+    def lct_schema_capabilities
+      columns = columns_hash
+      adapter_name = connection.adapter_name
+      cache = @lct_schema_capabilities
+
+      return cache.fetch(:values) if cache && cache.fetch(:columns).equal?(columns) &&
+                                     cache.fetch(:adapter_name) == adapter_name
+
+      values = build_lct_schema_capabilities(columns, adapter_name)
+      @lct_schema_capabilities = { columns: columns, adapter_name: adapter_name, values: values }
+      values
+    end
+
+    def build_lct_schema_capabilities(columns, adapter_name)
+      tag_column = columns["tags"]
+      tags_jsonb = tag_column && (tag_column.type == :jsonb || tag_column.sql_type.to_s.downcase == "jsonb")
+      tags_mysql_json = tag_column && !tags_jsonb && tag_column.type == :json && adapter_name.match?(/mysql/i)
+
+      {
+        tags_jsonb: tags_jsonb ? true : false,
+        tags_mysql_json: tags_mysql_json ? true : false,
+        latency: columns.key?("latency_ms"),
+        stream: columns.key?("stream"),
+        usage_source: columns.key?("usage_source"),
+        provider_response_id: columns.key?("provider_response_id"),
+        pricing_mode: columns.key?("pricing_mode"),
+        usage_breakdown: USAGE_BREAKDOWN_COLUMNS.all? { |column| columns.key?(column) },
+        usage_breakdown_cost: USAGE_BREAKDOWN_COST_COLUMNS.all? { |column| columns.key?(column) }
+      }
     end
   end
 end

data/lib/llm_cost_tracker/tracker.rb

@@ -16,28 +16,70 @@ module LlmCostTracker
       end
 
       def record(provider:, model:, input_tokens:, output_tokens:, latency_ms: nil, stream: false,
-                 usage_source: nil, provider_response_id: nil, metadata: {})
+                 usage_source: nil, provider_response_id: nil, pricing_mode: nil, metadata: {})
         return unless LlmCostTracker.configuration.enabled
 
-        usage = EventMetadata.usage_data(input_tokens, output_tokens, metadata)
+        usage = usage_data(input_tokens, output_tokens, metadata, pricing_mode)
+        cost_data = cost_for_usage(provider, model, usage)
 
-        cost_data = Pricing.cost_for(
+        UnknownPricing.handle!(model) unless cost_data
+
+        event = build_event(
+          provider: provider,
+          model: model,
+          usage: usage,
+          cost_data: cost_data,
+          metadata: metadata,
+          latency_ms: latency_ms,
+          stream: stream,
+          usage_source: usage_source,
+          provider_response_id: provider_response_id
+        )
+
+        ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
+
+        stored = store(event)
+        Budget.check!(event) unless stored == false
+
+        event
+      end
+
+      private
+
+      def usage_data(input_tokens, output_tokens, metadata, pricing_mode)
+        metadata = metadata.merge(pricing_mode: pricing_mode) unless pricing_mode.nil?
+
+        EventMetadata.usage_data(
+          input_tokens,
+          output_tokens,
+          metadata
+        )
+      end
+
+      def cost_for_usage(provider, model, usage)
+        Pricing.cost_for(
+          provider: provider,
           model: model,
           input_tokens: usage[:input_tokens],
           output_tokens: usage[:output_tokens],
-          cached_input_tokens: usage[:cached_input_tokens],
           cache_read_input_tokens: usage[:cache_read_input_tokens],
-          cache_creation_input_tokens: usage[:cache_creation_input_tokens]
+          cache_write_input_tokens: usage[:cache_write_input_tokens],
+          pricing_mode: usage[:pricing_mode]
         )
+      end
 
-        UnknownPricing.handle!(model) unless cost_data
-
-        event = Event.new(
+      def build_event(provider:, model:, usage:, cost_data:, metadata:, latency_ms:, stream:, usage_source:,
+                      provider_response_id:)
+        Event.new(
           provider: provider,
           model: model,
           input_tokens: usage[:input_tokens],
           output_tokens: usage[:output_tokens],
           total_tokens: usage[:total_tokens],
+          cache_read_input_tokens: usage[:cache_read_input_tokens],
+          cache_write_input_tokens: usage[:cache_write_input_tokens],
+          hidden_output_tokens: usage[:hidden_output_tokens],
+          pricing_mode: usage[:pricing_mode],
           cost: cost_data,
           tags: LlmCostTracker.configuration.default_tags.merge(EventMetadata.tags(metadata)).freeze,
           latency_ms: normalized_latency_ms(latency_ms),
@@ -46,17 +88,8 @@ module LlmCostTracker
           provider_response_id: normalized_provider_response_id(provider_response_id),
           tracked_at: Time.now.utc
         )
-
-        ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
-
-        stored = store(event)
-        Budget.check!(event) unless stored == false
-
-        event
       end
 
-      private
-
       def store(event)
         config = LlmCostTracker.configuration
         case config.storage_backend
@@ -73,7 +106,7 @@ module LlmCostTracker
 
       def log_event(event, config)
         message = "#{event.provider}/#{event.model} " \
-                  "tokens=#{event.input_tokens}+#{event.output_tokens} " \
+                  "tokens=#{event.total_tokens} " \
                   "cost=#{log_cost_label(event)}"
         message += " latency=#{event.latency_ms}ms" if event.latency_ms
         message += " stream=#{event.stream}" if event.stream
@@ -84,9 +117,7 @@ module LlmCostTracker
         event
       end
 
-      def log_cost_label(event)
-        event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
-      end
+      def log_cost_label(event) = event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
 
       def active_record_save(event)
         require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
@@ -115,11 +146,7 @@ module LlmCostTracker
         end
       end
 
-      def normalized_latency_ms(latency_ms)
-        return nil if latency_ms.nil?
-
-        [latency_ms.to_i, 0].max
-      end
+      def normalized_latency_ms(latency_ms) = latency_ms.nil? ? nil : [latency_ms.to_i, 0].max
 
       def normalized_usage_source(value)
         return nil if value.nil?
@@ -128,12 +155,7 @@ module LlmCostTracker
         USAGE_SOURCES.include?(symbol) ? symbol.to_s : nil
       end
 
-      def normalized_provider_response_id(value)
-        return nil if value.nil?
-
-        string = value.to_s
-        string.empty? ? nil : string
-      end
+      def normalized_provider_response_id(value) = value.nil? || value.to_s.empty? ? nil : value.to_s
     end
   end
 end

data/lib/llm_cost_tracker/usage_breakdown.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  UsageBreakdown = Data.define(
+    :input_tokens,
+    :cache_read_input_tokens,
+    :cache_write_input_tokens,
+    :output_tokens,
+    :hidden_output_tokens
+  ) do
+    def self.build(input_tokens:, output_tokens:, cache_read_input_tokens: 0,
+                   cache_write_input_tokens: 0, hidden_output_tokens: 0)
+      new(
+        input_tokens: input_tokens.to_i,
+        cache_read_input_tokens: cache_read_input_tokens.to_i,
+        cache_write_input_tokens: cache_write_input_tokens.to_i,
+        output_tokens: output_tokens.to_i,
+        hidden_output_tokens: hidden_output_tokens.to_i
+      )
+    end
+
+    def total_tokens
+      input_tokens + cache_read_input_tokens + cache_write_input_tokens + output_tokens
+    end
+
+    def to_h
+      super.merge(total_tokens: total_tokens).compact
+    end
+  end
+end

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.3.3"
+  VERSION = "0.4.1"
 end

data/lib/llm_cost_tracker.rb

@@ -10,6 +10,7 @@ require_relative "llm_cost_tracker/errors"
 require_relative "llm_cost_tracker/logging"
 require_relative "llm_cost_tracker/parameter_hash"
 require_relative "llm_cost_tracker/cost"
+require_relative "llm_cost_tracker/usage_breakdown"
 require_relative "llm_cost_tracker/event"
 require_relative "llm_cost_tracker/parsed_usage"
 require_relative "llm_cost_tracker/price_registry"
@@ -69,7 +70,7 @@ module LlmCostTracker
     end
 
     def track(provider:, model:, input_tokens:, output_tokens:, latency_ms: nil, stream: false, usage_source: :manual,
-              enforce_budget: false, provider_response_id: nil, **metadata)
+              enforce_budget: false, provider_response_id: nil, pricing_mode: nil, **metadata)
       enforce_budget! if enforce_budget
       Tracker.record(
         provider: provider.to_s,
@@ -80,11 +81,13 @@ module LlmCostTracker
         stream: stream,
         usage_source: usage_source,
         provider_response_id: provider_response_id,
+        pricing_mode: pricing_mode,
         metadata: metadata
       )
     end
 
-    def track_stream(provider:, model:, latency_ms: nil, enforce_budget: false, provider_response_id: nil, **metadata)
+    def track_stream(provider:, model:, latency_ms: nil, enforce_budget: false, provider_response_id: nil,
+                     pricing_mode: nil, **metadata)
       require_relative "llm_cost_tracker/stream_collector"
       enforce_budget! if enforce_budget
       collector = StreamCollector.new(
@@ -92,6 +95,7 @@ module LlmCostTracker
         model: model,
         latency_ms: latency_ms,
         provider_response_id: provider_response_id,
+        pricing_mode: pricing_mode,
         metadata: metadata
       )
       yield collector
@@ -107,7 +111,10 @@ module LlmCostTracker
       return unless config.budget_exceeded_behavior == :block_requests
       return if config.active_record?
 
-      Logging.warn(":block_requests requires storage_backend = :active_record; preflight blocking will be skipped.")
+      Logging.warn(
+        ":block_requests requires storage_backend = :active_record for monthly and daily preflight; " \
+        "preflight blocking will be skipped."
+      )
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.1
 platform: ruby
 authors:
 - Sergii Khomenko
@@ -240,6 +240,7 @@ files:
 - app/helpers/llm_cost_tracker/dashboard_query_helper.rb
 - app/helpers/llm_cost_tracker/pagination_helper.rb
 - app/services/llm_cost_tracker/dashboard/data_quality.rb
+- app/services/llm_cost_tracker/dashboard/data_quality_aggregate.rb
 - app/services/llm_cost_tracker/dashboard/filter.rb
 - app/services/llm_cost_tracker/dashboard/overview_stats.rb
 - app/services/llm_cost_tracker/dashboard/provider_breakdown.rb
@@ -278,15 +279,17 @@ files:
 - lib/llm_cost_tracker/event.rb
 - lib/llm_cost_tracker/event_metadata.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/add_latency_ms_generator.rb
-- lib/llm_cost_tracker/generators/llm_cost_tracker/add_monthly_totals_generator.rb
+- lib/llm_cost_tracker/generators/llm_cost_tracker/add_period_totals_generator.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/add_provider_response_id_generator.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/add_streaming_generator.rb
+- lib/llm_cost_tracker/generators/llm_cost_tracker/add_usage_breakdown_generator.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/install_generator.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/prices_generator.rb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_latency_ms_to_llm_api_calls.rb.erb
-- lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_monthly_totals_to_llm_cost_tracker.rb.erb
+- lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_period_totals_to_llm_cost_tracker.rb.erb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_provider_response_id_to_llm_api_calls.rb.erb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_streaming_to_llm_api_calls.rb.erb
+- lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_usage_breakdown_to_llm_api_calls.rb.erb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_api_calls.rb.erb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/initializer.rb.erb
 - lib/llm_cost_tracker/generators/llm_cost_tracker/templates/llm_cost_tracker_prices.yml.erb
@@ -297,7 +300,6 @@ files:
 - lib/llm_cost_tracker/llm_api_call.rb
 - lib/llm_cost_tracker/logging.rb
 - lib/llm_cost_tracker/middleware/faraday.rb
-- lib/llm_cost_tracker/monthly_total.rb
 - lib/llm_cost_tracker/parameter_hash.rb
 - lib/llm_cost_tracker/parsed_usage.rb
 - lib/llm_cost_tracker/parsers/anthropic.rb
@@ -309,6 +311,7 @@ files:
 - lib/llm_cost_tracker/parsers/registry.rb
 - lib/llm_cost_tracker/parsers/sse.rb
 - lib/llm_cost_tracker/period_grouping.rb
+- lib/llm_cost_tracker/period_total.rb
 - lib/llm_cost_tracker/price_registry.rb
 - lib/llm_cost_tracker/price_sync.rb
 - lib/llm_cost_tracker/price_sync/fetcher.rb
@@ -330,6 +333,7 @@ files:
 - lib/llm_cost_tracker/report_data.rb
 - lib/llm_cost_tracker/report_formatter.rb
 - lib/llm_cost_tracker/retention.rb
+- lib/llm_cost_tracker/storage/active_record_rollups.rb
 - lib/llm_cost_tracker/storage/active_record_store.rb
 - lib/llm_cost_tracker/stream_collector.rb
 - lib/llm_cost_tracker/tag_accessors.rb
@@ -338,6 +342,7 @@ files:
 - lib/llm_cost_tracker/tags_column.rb
 - lib/llm_cost_tracker/tracker.rb
 - lib/llm_cost_tracker/unknown_pricing.rb
+- lib/llm_cost_tracker/usage_breakdown.rb
 - lib/llm_cost_tracker/value_helpers.rb
 - lib/llm_cost_tracker/version.rb
 - lib/tasks/llm_cost_tracker.rake

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

@@ -1,48 +0,0 @@
-class AddMonthlyTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_version %>
-  def up
-    create_table :llm_cost_tracker_monthly_totals do |t|
-      t.date :month_start, null: false
-      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
-
-      t.timestamps
-    end unless table_exists?(:llm_cost_tracker_monthly_totals)
-
-    add_index :llm_cost_tracker_monthly_totals, :month_start,
-              unique: true unless index_exists?(:llm_cost_tracker_monthly_totals, :month_start)
-
-    backfill_monthly_totals
-  end
-
-  def down
-    remove_index :llm_cost_tracker_monthly_totals, :month_start if index_exists?(:llm_cost_tracker_monthly_totals, :month_start)
-    drop_table :llm_cost_tracker_monthly_totals if table_exists?(:llm_cost_tracker_monthly_totals)
-  end
-
-  private
-
-  def backfill_monthly_totals
-    return unless table_exists?(:llm_api_calls)
-
-    execute <<~SQL
-      INSERT INTO llm_cost_tracker_monthly_totals (month_start, total_cost, created_at, updated_at)
-      SELECT #{month_bucket_sql} AS month_start,
-             SUM(total_cost) AS total_cost,
-             CURRENT_TIMESTAMP,
-             CURRENT_TIMESTAMP
-      FROM llm_api_calls
-      WHERE total_cost IS NOT NULL
-      GROUP BY #{month_bucket_sql}
-    SQL
-  end
-
-  def month_bucket_sql
-    case connection.adapter_name
-    when /postgres/i
-      "DATE_TRUNC('month', tracked_at)::date"
-    when /mysql/i
-      "DATE_FORMAT(tracked_at, '%Y-%m-01')"
-    else
-      "strftime('%Y-%m-01', tracked_at)"
-    end
-  end
-end

data/lib/llm_cost_tracker/monthly_total.rb

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