llm_cost_tracker 0.7.2 → 0.8.0

data/lib/llm_cost_tracker/ledger/tags/sql.rb

@@ -1,30 +1,43 @@
 # frozen_string_literal: true
 
-require_relative "../schema/adapter"
 require_relative "../../tags/key"
 
 module LlmCostTracker
   module Ledger
     module Tags
       module Sql
+        UNTAGGED_LABEL = "(untagged)"
+
         class << self
-          def value_expression(model, key, table_name:)
-            key = LlmCostTracker::Tags::Key.validate!(key)
-            column = "#{table_name}.#{model.connection.quote_column_name('tags')}"
-
-            if Ledger::Schema::Adapter.postgresql?(model.connection)
-              "#{column}->>#{model.connection.quote(key)}"
-            elsif Ledger::Schema::Adapter.mysql?(model.connection)
-              "JSON_UNQUOTE(JSON_EXTRACT(#{column}, #{model.connection.quote(json_path(key))}))"
-            else
-              Ledger::Schema::Adapter.ensure_supported!(model.connection)
-            end
+          def join_relation(scope, key)
+            validated_key = LlmCostTracker::Tags::Key.validate!(key)
+            connection = scope.connection
+            join = "LEFT OUTER JOIN #{call_tag_table} ON " \
+                   "#{call_tag_table}.llm_cost_tracker_call_id = #{scope.quoted_table_name}.id AND " \
+                   "#{call_tag_table}.#{connection.quote_column_name('key')} = #{connection.quote(validated_key)}"
+            scope.joins(join)
+          end
+
+          def value_arel
+            Arel.sql("#{call_tag_table}.#{quote_column('value')}")
+          end
+
+          def label_sql(connection)
+            "COALESCE(NULLIF(#{raw_value_sql(connection)}, ''), #{connection.quote(UNTAGGED_LABEL)})"
+          end
+
+          def raw_value_sql(connection)
+            "#{call_tag_table}.#{connection.quote_column_name('value')}"
           end
 
           private
 
-          def json_path(key)
-            "$.\"#{key}\""
+          def call_tag_table
+            LlmCostTracker::CallTag.quoted_table_name
+          end
+
+          def quote_column(name)
+            LlmCostTracker::CallTag.connection.quote_column_name(name)
           end
         end
       end

data/lib/llm_cost_tracker/ledger.rb

@@ -2,11 +2,13 @@
 
 require_relative "ledger/schema/adapter"
 require_relative "ledger/schema/calls"
-require_relative "ledger/schema/period_totals"
+require_relative "ledger/schema/call_rollups"
+require_relative "ledger/schema/call_line_items"
+require_relative "ledger/schema/call_tags"
+require_relative "ledger/schema/provider_invoices"
 require_relative "ledger/tags/query"
 require_relative "ledger/tags/sql"
 require_relative "ledger/period"
-require_relative "ledger/rollups/batch"
 require_relative "ledger/rollups/upsert_sql"
 require_relative "ledger/rollups"
 require_relative "ledger/store"

data/lib/llm_cost_tracker/logging.rb

@@ -20,12 +20,9 @@ module LlmCostTracker
       def log(level, message)
         message = prefixed(message)
         logger = Rails.logger
+        return Kernel.warn(message) unless logger
 
-        if logger
-          logger.try(level, message)
-        else
-          Kernel.warn(message)
-        end
+        logger.public_send(level, message)
       end
 
       private

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -6,6 +6,7 @@ require "uri"
 
 require_relative "../logging"
 require_relative "../capture/stream"
+require_relative "../timing"
 
 module LlmCostTracker
   module Middleware
@@ -19,14 +20,14 @@ module LlmCostTracker
         return @app.call(request_env) unless LlmCostTracker.configuration.enabled
 
         request_url  = request_env.url.to_s
-        request_body = read_body(request_env.body) || ""
+        request_body = read_body(request_env.body)
         parser       = Parsers.find_for(request_url)
         streaming    = parser&.streaming_request?(request_url, request_body)
         stream_buffer = install_stream_tap(request_env) if streaming
 
         Tracker.enforce_budget! if parser
         context_tags, metadata = tag_snapshot(request_env) if parser
-        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        started_at = LlmCostTracker::Timing.now_monotonic
 
         @app.call(request_env).on_complete do |response_env|
           process(
@@ -34,7 +35,7 @@ module LlmCostTracker
             request_url: request_url,
             request_body: request_body,
             response_env: response_env,
-            latency_ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round,
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
             streaming: streaming,
             stream_buffer: stream_buffer,
             context_tags: context_tags,
@@ -135,7 +136,7 @@ module LlmCostTracker
       end
 
       def install_stream_tap(request_env)
-        request = request_env.try(:request)
+        request = request_env.request
         return nil unless request
 
         original = request.on_data
@@ -204,8 +205,8 @@ module LlmCostTracker
         uri = URI.parse(value.to_s)
         uri.query = nil
         uri.fragment = nil
-        uri.try(:user=, nil)
-        uri.try(:password=, nil)
+        uri.user = nil
+        uri.password = nil
         uri.to_s
       rescue URI::InvalidURIError
         value.to_s.split("?", 2).first

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -31,7 +31,8 @@ module LlmCostTracker
           pricing_mode: pricing_mode(request: request, response: response, usage: usage),
           model: response["model"] || request["model"],
           token_usage: token_usage(usage: usage, cache_read: cache_read),
-          usage_source: :response
+          usage_source: :response,
+          service_line_items: service_line_items(usage)
         )
       end
 
@@ -87,7 +88,39 @@ module LlmCostTracker
           model: model,
           token_usage: token_usage(usage: usage, cache_read: cache_read),
           stream: true,
-          usage_source: :stream_final
+          usage_source: :stream_final,
+          service_line_items: service_line_items(usage)
+        )
+      end
+
+      def service_line_items(usage)
+        server_tool_use = usage["server_tool_use"]
+        return [] unless server_tool_use.is_a?(Hash)
+
+        [
+          service_line_item(
+            component_key: :web_search_request,
+            quantity: server_tool_use["web_search_requests"],
+            provider_field: "usage.server_tool_use.web_search_requests"
+          ),
+          service_line_item(
+            component_key: :code_execution_request,
+            quantity: server_tool_use["code_execution_requests"],
+            provider_field: "usage.server_tool_use.code_execution_requests"
+          )
+        ].compact
+      end
+
+      def service_line_item(component_key:, quantity:, provider_field:)
+        quantity = quantity.to_i
+        return if quantity.zero?
+
+        Billing::LineItem.build(
+          component_key: component_key,
+          quantity: quantity,
+          cost_status: Billing::CostStatus::UNKNOWN,
+          pricing_basis: :provider_usage,
+          provider_field: provider_field
         )
       end
 
@@ -97,22 +130,34 @@ module LlmCostTracker
         cache_creation = usage["cache_creation"]
         if cache_creation.is_a?(Hash)
           cache_write = cache_creation["ephemeral_5m_input_tokens"].to_i
-          cache_write_1h = cache_creation["ephemeral_1h_input_tokens"].to_i
+          cache_write_extended = cache_creation["ephemeral_1h_input_tokens"].to_i
         else
+          warn_unexpected_cache_creation(cache_creation, usage)
           cache_write = usage["cache_creation_input_tokens"].to_i
-          cache_write_1h = 0
+          cache_write_extended = 0
         end
+        hidden_output = (
+          usage["thinking_tokens"] || usage["thinking_output_tokens"] ||
+            usage.dig("output_tokens_details", "reasoning_tokens")
+        ).to_i
 
         TokenUsage.build(
           input_tokens: input,
           output_tokens: output,
-          total_tokens: input + output + cache_read + cache_write + cache_write_1h,
-          cache_read_input_tokens: usage["cache_read_input_tokens"],
+          total_tokens: input + output + cache_read + cache_write + cache_write_extended,
+          cache_read_input_tokens: cache_read,
           cache_write_input_tokens: cache_write,
-          cache_write_1h_input_tokens: cache_write_1h
+          cache_write_extended_input_tokens: cache_write_extended,
+          hidden_output_tokens: hidden_output
         )
       end
 
+      def warn_unexpected_cache_creation(cache_creation, usage)
+        return if cache_creation.nil? || usage.key?("cache_creation_input_tokens")
+
+        Logging.warn("Anthropic usage.cache_creation has unexpected shape: #{cache_creation.class}")
+      end
+
       def pricing_mode(request:, response:, usage:)
         modes = []
         speed = usage&.fetch("speed", nil) || response&.fetch("speed", nil) || request["speed"]

data/lib/llm_cost_tracker/parsers/base.rb

@@ -59,7 +59,10 @@ module LlmCostTracker
           )
           extra_match = block_given? ? yield(uri) : true
 
-          host_match && path_match && extra_match ? true : false
+          next false unless host_match && path_match
+          next false unless extra_match
+
+          true
         end
       end
 
@@ -100,7 +103,8 @@ module LlmCostTracker
         nil
       end
 
-      def build_unknown_stream_usage(provider:, model:, provider_response_id:, pricing_mode: nil)
+      def build_unknown_stream_usage(provider:, model:, provider_response_id:, pricing_mode: nil,
+                                     service_line_items: nil)
         UsageCapture.build(
           provider: provider,
           provider_response_id: provider_response_id,
@@ -108,7 +112,8 @@ module LlmCostTracker
           model: model || UsageCapture::UNKNOWN_MODEL,
           token_usage: TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
           stream: true,
-          usage_source: :unknown
+          usage_source: :unknown,
+          service_line_items: service_line_items
         )
       end
     end

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../billing/line_item"
 require_relative "base"
 
 module LlmCostTracker
@@ -8,6 +9,7 @@ module LlmCostTracker
       HOSTS = %w[generativelanguage.googleapis.com].freeze
       TRACKED_PATH_PATTERN = %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}
       STREAM_PATH_PATTERN  = /:streamGenerateContent\z/
+      PER_QUERY_GROUNDING_MODEL_PATTERN = /\bgemini-(?:[3-9]|[1-9]\d)\b/i
 
       def match?(url)
         match_uri?(url, hosts: HOSTS, path_pattern: TRACKED_PATH_PATTERN)
@@ -31,12 +33,14 @@ module LlmCostTracker
         return nil unless usage
 
         request = safe_json_parse(request_body)
+        model = extract_model_from_url(request_url)
         build_usage_capture(
           request_url: request_url,
           usage: usage,
           usage_source: :response,
           provider_response_id: response["responseId"],
-          pricing_mode: pricing_mode(request: request, response_headers: response_headers)
+          pricing_mode: pricing_mode(request: request, response_headers: response_headers),
+          service_line_items: grounding_line_items_for_response(response, model: model)
         )
       end
 
@@ -48,6 +52,7 @@ module LlmCostTracker
         model = extract_model_from_url(request_url)
         response_id = stream_response_id(events)
         mode = pricing_mode(request: request, response_headers: response_headers)
+        service_line_items = grounding_line_items_for_stream(events, model: model)
 
         if usage
           build_usage_capture(
@@ -56,14 +61,16 @@ module LlmCostTracker
             stream: true,
             usage_source: :stream_final,
             provider_response_id: response_id,
-            pricing_mode: mode
+            pricing_mode: mode,
+            service_line_items: service_line_items
           )
         else
           build_unknown_stream_usage(
             provider: "gemini",
             model: model,
             provider_response_id: response_id,
-            pricing_mode: mode
+            pricing_mode: mode,
+            service_line_items: service_line_items
           )
         end
       end
@@ -71,24 +78,30 @@ module LlmCostTracker
       private
 
       def build_usage_capture(request_url:, usage:, usage_source:, stream: false, provider_response_id: nil,
-                              pricing_mode: nil)
+                              pricing_mode: nil, service_line_items: nil)
         cache_read = usage["cachedContentTokenCount"].to_i
         tool_use_prompt = usage["toolUsePromptTokenCount"].to_i
+        audio_input = audio_input_tokens(usage)
+        audio_output = audio_output_tokens(usage)
 
         UsageCapture.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
           pricing_mode: pricing_mode,
           token_usage: TokenUsage.build(
-            input_tokens: [usage["promptTokenCount"].to_i - cache_read, 0].max + tool_use_prompt,
-            output_tokens: output_tokens(usage),
-            total_tokens: total_tokens(usage: usage, cache_read: cache_read, tool_use_prompt: tool_use_prompt),
-            cache_read_input_tokens: usage["cachedContentTokenCount"],
+            input_tokens: regular_input_tokens(usage: usage, cache_read: cache_read, audio_input: audio_input) +
+                          tool_use_prompt,
+            output_tokens: regular_output_tokens(usage: usage, audio_output: audio_output),
+            total_tokens: usage["totalTokenCount"],
+            cache_read_input_tokens: cache_read,
+            audio_input_tokens: audio_input,
+            audio_output_tokens: audio_output,
             hidden_output_tokens: usage["thoughtsTokenCount"]
           ),
           stream: stream,
           usage_source: usage_source,
-          provider_response_id: provider_response_id
+          provider_response_id: provider_response_id,
+          service_line_items: service_line_items
         )
       end
 
@@ -100,14 +113,41 @@ module LlmCostTracker
       end
 
       def output_tokens(usage)
-        usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
+        (usage["candidatesTokenCount"] || usage["responseTokenCount"]).to_i + usage["thoughtsTokenCount"].to_i
+      end
+
+      def regular_input_tokens(usage:, cache_read:, audio_input:)
+        [usage["promptTokenCount"].to_i - cache_read - audio_input, 0].max
+      end
+
+      def regular_output_tokens(usage:, audio_output:)
+        [output_tokens(usage) - audio_output, 0].max
+      end
+
+      def audio_input_tokens(usage)
+        prompt_audio = modality_tokens(usage["promptTokensDetails"] || usage["prompt_tokens_details"], "AUDIO")
+        cache_audio = modality_tokens(usage["cacheTokensDetails"] || usage["cache_tokens_details"], "AUDIO")
+        [prompt_audio - cache_audio, 0].max
       end
 
-      def total_tokens(usage:, cache_read:, tool_use_prompt:)
-        total = usage["totalTokenCount"]
-        return total.to_i unless total.nil?
+      def audio_output_tokens(usage)
+        modality_tokens(
+          usage["candidatesTokensDetails"] ||
+            usage["candidates_tokens_details"] ||
+            usage["responseTokensDetails"] ||
+            usage["response_tokens_details"],
+          "AUDIO"
+        )
+      end
+
+      def modality_tokens(details, modality)
+        Array(details).sum do |detail|
+          next 0 unless detail.is_a?(Hash)
+
+          next 0 unless detail["modality"] == modality
 
-        [usage["promptTokenCount"].to_i - cache_read, 0].max + cache_read + tool_use_prompt + output_tokens(usage)
+          (detail["tokenCount"] || detail["token_count"]).to_i
+        end
       end
 
       def stream_response_id(events)
@@ -133,12 +173,58 @@ module LlmCostTracker
           request.dig("config", "service_tier") ||
           request.dig("config", "serviceTier")
         )
-        request_mode == "flex" ? request_mode : nil
+        request_mode == :flex ? request_mode : nil
       end
 
       def response_header(headers, name)
         headers.to_h.find { |key, _value| key.to_s.downcase == name }&.last
       end
+
+      def grounding_line_items_for_response(response, model:)
+        grounding_line_items(grounding_request_count(response["candidates"]), model: model)
+      end
+
+      def grounding_line_items_for_stream(events, model:)
+        quantity = find_event_value(events, reverse: true) do |data|
+          count = grounding_request_count(data["candidates"])
+          count if count.positive?
+        end
+        grounding_line_items(quantity || 0, model: model)
+      end
+
+      def grounding_request_count(candidates)
+        Array(candidates).sum do |candidate|
+          next 0 unless candidate.is_a?(Hash)
+
+          metadata = candidate["groundingMetadata"] || candidate["grounding_metadata"] || {}
+          queries = metadata["webSearchQueries"] || metadata["web_search_queries"] || []
+          Array(queries).size
+        end
+      end
+
+      def grounding_line_items(query_count, model:)
+        return [] unless query_count.positive?
+
+        billed_quantity = grounding_billed_quantity(query_count, model: model)
+        [
+          Billing::LineItem.build(
+            component_key: :grounding_request,
+            quantity: billed_quantity,
+            cost_status: Billing::CostStatus::UNKNOWN,
+            pricing_basis: :provider_usage,
+            provider_field: "response.candidates.groundingMetadata.webSearchQueries",
+            details: { web_search_queries: query_count }
+          )
+        ]
+      end
+
+      def grounding_billed_quantity(query_count, model:)
+        per_query_billing?(model) ? query_count : 1
+      end
+
+      def per_query_billing?(model)
+        model.to_s.match?(PER_QUERY_GROUNDING_MODEL_PATTERN)
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -15,10 +15,18 @@ module LlmCostTracker
       end
 
       def provider_names
-        [
+        providers = LlmCostTracker.configuration.openai_compatible_providers
+        cached = @provider_names
+        return cached if cached && @provider_names_providers.equal?(providers)
+
+        names = [
           "openai_compatible",
-          *LlmCostTracker.configuration.openai_compatible_providers.each_value.map(&:to_s)
+          *providers.each_value.map { |provider| provider.to_s.downcase }
         ].uniq.freeze
+        return names unless providers.frozen?
+
+        @provider_names_providers = providers
+        @provider_names = names
       end
 
       def parse(request_url:, request_body:, response_status:, response_body:, **)

data/lib/llm_cost_tracker/parsers/openai_service_charges.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../billing/line_item"
+
+module LlmCostTracker
+  module Parsers
+    module OpenaiServiceCharges
+      RESPONSE_OUTPUT_COMPONENTS = {
+        "web_search_call" => :web_search_request,
+        "file_search_call" => :file_search_call,
+        "code_interpreter_call" => :container_session
+      }.freeze
+
+      module_function
+
+      def line_items_from_output(output_items)
+        deduped = {}
+        Array(output_items).each { |item| store_output_item(deduped, item) }
+        deduped.values.filter_map { |item| build_line_item(item) }
+      end
+
+      def billable?(item)
+        return false unless item.is_a?(Hash)
+
+        component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+        return false unless component
+        return true unless component == :web_search_request
+
+        action_type = item.dig("action", "type")
+        action_type.nil? || action_type == "search"
+      end
+
+      def store_output_item(output_items, item)
+        return unless billable?(item)
+
+        component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+        key = if component == :container_session && item["container_id"]
+                "#{component}:#{item['container_id']}"
+              else
+                item["id"] || "#{item['type']}:#{output_items.length}"
+              end
+        output_items[key] = item
+      end
+
+      def build_line_item(item)
+        component_key = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+        return nil unless component_key
+
+        provider_item_id = if component_key == :container_session
+                             item["container_id"] || item["id"]
+                           else
+                             item["id"]
+                           end
+        Billing::LineItem.build(
+          component_key: component_key,
+          quantity: 1,
+          cost_status: Billing::CostStatus::UNKNOWN,
+          pricing_basis: :provider_usage,
+          provider_field: "response.output.#{item['type']}",
+          provider_item_id: provider_item_id,
+          details: line_item_details(item)
+        )
+      end
+
+      def line_item_details(item)
+        {
+          "status" => item["status"],
+          "action_type" => item.dig("action", "type"),
+          "container_id" => item["container_id"]
+        }.compact
+      end
+
+      def openai_service_line_items(response)
+        line_items_from_output(response["output"])
+      end
+
+      def openai_stream_service_line_items(events)
+        output_items = []
+        each_event_data(events) do |data|
+          output_items.concat(Array(data.dig("response", "output")))
+          output_items << data["item"] if data["item"]
+        end
+        line_items_from_output(output_items)
+      end
+    end
+  end
+end