llm_cost_tracker 0.1.1 → 0.1.3

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "faraday"
+require "json"
+
+require_relative "../logging"
 
 module LlmCostTracker
   module Middleware
@@ -14,25 +17,23 @@ 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) || ""
+
+        enforce_budget_before_request(request_url)
+        started_at = monotonic_time
 
         @app.call(request_env).on_complete do |response_env|
-          process(request_url, request_body, response_env)
+          process(request_env, request_url, request_body, response_env, elapsed_ms(started_at))
         end
       end
 
       private
 
-      def process(request_url, request_body, response_env)
+      def process(request_env, request_url, request_body, response_env, latency_ms)
         parser = Parsers::Registry.find_for(request_url)
         return unless parser
 
-        parsed = parser.parse(
-          request_url,
-          request_body,
-          response_env.status,
-          read_body(response_env.body)
-        )
+        parsed = parse_response(parser, request_url, request_body, response_env)
         return unless parsed
 
         Tracker.record(
@@ -40,21 +41,61 @@ module LlmCostTracker
           model: parsed[:model],
           input_tokens: parsed[:input_tokens],
           output_tokens: parsed[:output_tokens],
-          metadata: @tags.merge(parsed.except(:provider, :model, :input_tokens, :output_tokens, :total_tokens))
+          latency_ms: latency_ms,
+          metadata: resolved_tags(request_env).merge(parsed.metadata)
         )
+      rescue LlmCostTracker::Error
+        raise
       rescue StandardError => e
-        return unless LlmCostTracker.configuration.log_level == :debug
+        Logging.warn("Error processing response: #{e.class}: #{e.message}")
+      end
+
+      def parse_response(parser, request_url, request_body, response_env)
+        response_body = read_body(response_env.body)
+        unless response_body
+          Logging.warn(
+            "Unable to read response body for #{request_url}; streaming/SSE responses require manual tracking."
+          )
+          return nil
+        end
+
+        parser.parse(request_url, request_body, response_env.status, response_body)
+      end
+
+      def enforce_budget_before_request(request_url)
+        return unless Parsers::Registry.find_for(request_url)
 
-        warn "[LlmCostTracker] Error processing response: #{e.message}"
+        Tracker.enforce_budget!
       end
 
       def read_body(body)
         case body
         when String then body
         when nil then ""
-        else body.to_s
+        when Hash, Array then body.to_json
+        else
+          body.respond_to?(:to_str) ? body.to_str : nil
         end
       end
+
+      def resolved_tags(request_env)
+        tags = @tags.respond_to?(:call) ? call_tags(request_env) : @tags
+        return {} if tags.nil?
+
+        tags.to_h
+      end
+
+      def call_tags(request_env)
+        @tags.arity.zero? ? @tags.call : @tags.call(request_env)
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def elapsed_ms(started_at)
+        ((monotonic_time - started_at) * 1000).round
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "value_object"
+
+module LlmCostTracker
+  ParsedUsage = ValueObject.define(
+    :provider,
+    :model,
+    :input_tokens,
+    :output_tokens,
+    :total_tokens,
+    :cached_input_tokens,
+    :cache_read_input_tokens,
+    :cache_creation_input_tokens,
+    :reasoning_tokens
+  )
+
+  ParsedUsage.const_set(:TRACKING_KEYS, %i[provider model input_tokens output_tokens total_tokens].freeze)
+
+  class << ParsedUsage
+    def build(**attributes)
+      new(
+        provider: attributes.fetch(:provider),
+        model: attributes.fetch(:model),
+        input_tokens: attributes.fetch(:input_tokens).to_i,
+        output_tokens: attributes.fetch(:output_tokens).to_i,
+        total_tokens: attributes.fetch(:total_tokens, 0).to_i,
+        cached_input_tokens: attributes[:cached_input_tokens],
+        cache_read_input_tokens: attributes[:cache_read_input_tokens],
+        cache_creation_input_tokens: attributes[:cache_creation_input_tokens],
+        reasoning_tokens: attributes[:reasoning_tokens]
+      )
+    end
+  end
+
+  class ParsedUsage
+    def metadata
+      except(*TRACKING_KEYS)
+    end
+
+    def to_h
+      super.compact
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
+require "uri"
+
+require_relative "base"
 
 module LlmCostTracker
   module Parsers
@@ -9,7 +11,7 @@ module LlmCostTracker
 
       def match?(url)
         uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host) && uri.path.include?("/v1/messages")
+        HOSTS.include?(uri.host.to_s.downcase) && uri.path.include?("/v1/messages")
       rescue URI::InvalidURIError
         false
       end
@@ -23,7 +25,7 @@ module LlmCostTracker
 
         request = safe_json_parse(request_body)
 
-        {
+        ParsedUsage.build(
           provider: "anthropic",
           model: response["model"] || request["model"],
           input_tokens: usage["input_tokens"] || 0,
@@ -33,7 +35,7 @@ module LlmCostTracker
             (usage["cache_creation_input_tokens"] || 0),
           cache_read_input_tokens: usage["cache_read_input_tokens"],
           cache_creation_input_tokens: usage["cache_creation_input_tokens"]
-        }.compact
+        )
       end
     end
   end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module LlmCostTracker
   module Parsers
     class Base

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
-require "json"
+require "uri"
+
+require_relative "base"
 
 module LlmCostTracker
   module Parsers
     class Gemini < Base
       HOSTS = %w[generativelanguage.googleapis.com].freeze
+      TRACKED_PATH_PATTERN = %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}
 
       def match?(url)
         uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host)
+        HOSTS.include?(uri.host.to_s.downcase) && uri.path.match?(TRACKED_PATH_PATTERN)
       rescue URI::InvalidURIError
         false
       end
@@ -24,18 +27,22 @@ module LlmCostTracker
         # Extract model from URL: /v1beta/models/gemini-2.5-flash:generateContent
         model = extract_model_from_url(request_url)
 
-        {
+        ParsedUsage.build(
           provider: "gemini",
           model: model,
           input_tokens: usage["promptTokenCount"] || 0,
-          output_tokens: usage["candidatesTokenCount"] || 0,
+          output_tokens: output_tokens(usage),
           total_tokens: usage["totalTokenCount"] || 0,
           cached_input_tokens: usage["cachedContentTokenCount"]
-        }.compact
+        )
       end
 
       private
 
+      def output_tokens(usage)
+        (usage["candidatesTokenCount"] || 0) + (usage["thoughtsTokenCount"] || 0)
+      end
+
       def extract_model_from_url(url)
         uri = URI.parse(url.to_s)
         match = uri.path.match(%r{/models/([^/:]+)})

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -1,44 +1,33 @@
 # frozen_string_literal: true
 
-require "json"
+require "uri"
+
+require_relative "base"
+require_relative "openai_usage"
 
 module LlmCostTracker
   module Parsers
     class Openai < Base
+      include OpenaiUsage
+
       HOSTS = %w[api.openai.com].freeze
       TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
 
       def match?(url)
         uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host) && TRACKED_PATHS.include?(uri.path)
+        HOSTS.include?(uri.host.to_s.downcase) && TRACKED_PATHS.include?(uri.path)
       rescue URI::InvalidURIError
         false
       end
 
-      def parse(_request_url, request_body, response_status, response_body)
-        return nil unless response_status == 200
-
-        response = safe_json_parse(response_body)
-        usage    = response["usage"]
-        return nil unless usage
-
-        request = safe_json_parse(request_body)
-
-        {
-          provider: "openai",
-          model: response["model"] || request["model"],
-          input_tokens: usage["prompt_tokens"] || usage["input_tokens"] || 0,
-          output_tokens: usage["completion_tokens"] || usage["output_tokens"] || 0,
-          total_tokens: usage["total_tokens"] || 0,
-          cached_input_tokens: cached_input_tokens(usage)
-        }.compact
+      def parse(request_url, request_body, response_status, response_body)
+        parse_openai_usage(request_url, request_body, response_status, response_body)
       end
 
       private
 
-      def cached_input_tokens(usage)
-        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
-        details["cached_tokens"]
+      def provider_for(_request_url)
+        "openai"
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require_relative "base"
+require_relative "openai_usage"
+
+module LlmCostTracker
+  module Parsers
+    class OpenaiCompatible < Base
+      include OpenaiUsage
+
+      TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
+
+      def match?(url)
+        uri = URI.parse(url.to_s)
+        !provider_for_host(uri.host).nil? && tracked_path?(uri.path)
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def parse(request_url, request_body, response_status, response_body)
+        parse_openai_usage(request_url, request_body, response_status, response_body)
+      end
+
+      private
+
+      def provider_for(request_url)
+        uri = URI.parse(request_url.to_s)
+        provider_for_host(uri.host) || "openai_compatible"
+      rescue URI::InvalidURIError
+        "openai_compatible"
+      end
+
+      def provider_for_host(host)
+        configured_providers[host.to_s.downcase]&.to_s
+      end
+
+      def configured_providers
+        LlmCostTracker.configuration.openai_compatible_providers
+      end
+
+      def tracked_path?(path)
+        TRACKED_PATH_SUFFIXES.any? { |suffix| path == suffix || path.end_with?(suffix) }
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Parsers
+    module OpenaiUsage
+      private
+
+      def parse_openai_usage(request_url, request_body, response_status, response_body)
+        return nil unless response_status == 200
+
+        response = safe_json_parse(response_body)
+        usage = response["usage"]
+        return nil unless usage
+
+        request = safe_json_parse(request_body)
+
+        ParsedUsage.build(
+          provider: provider_for(request_url),
+          model: response["model"] || request["model"],
+          input_tokens: usage["prompt_tokens"] || usage["input_tokens"] || 0,
+          output_tokens: usage["completion_tokens"] || usage["output_tokens"] || 0,
+          total_tokens: usage["total_tokens"] || 0,
+          cached_input_tokens: cached_input_tokens(usage)
+        )
+      end
+
+      def cached_input_tokens(usage)
+        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
+        details["cached_tokens"]
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/registry.rb

@@ -4,16 +4,14 @@ module LlmCostTracker
   module Parsers
     class Registry
       class << self
+        PARSERS_MUTEX = Mutex.new
+
         def parsers
-          @parsers ||= [
-            Openai.new,
-            Anthropic.new,
-            Gemini.new
-          ]
+          @parsers || PARSERS_MUTEX.synchronize { @parsers ||= default_parsers }
         end
 
         def register(parser)
-          parsers.unshift(parser)
+          PARSERS_MUTEX.synchronize { parsers.unshift(parser) }
         end
 
         def find_for(url)
@@ -21,7 +19,18 @@ module LlmCostTracker
         end
 
         def reset!
-          @parsers = nil
+          PARSERS_MUTEX.synchronize { @parsers = nil }
+        end
+
+        private
+
+        def default_parsers
+          [
+            Openai.new,
+            OpenaiCompatible.new,
+            Anthropic.new,
+            Gemini.new
+          ]
         end
       end
     end

data/lib/llm_cost_tracker/price_registry.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+require_relative "logging"
+
+module LlmCostTracker
+  module PriceRegistry
+    DEFAULT_PRICES_PATH = File.expand_path("prices.json", __dir__)
+    EMPTY_PRICES = {}.freeze
+    PRICE_KEYS = %w[input cached_input output cache_read_input cache_creation_input].freeze
+    METADATA_KEYS = %w[_source _updated _notes].freeze
+    FILE_PRICES_MUTEX = Mutex.new
+    NORMALIZE_PRICE_ENTRY = lambda do |price|
+      (price || {}).each_with_object({}) do |(key, value), normalized|
+        key = key.to_s
+        normalized[key.to_sym] = Float(value) if PRICE_KEYS.include?(key)
+      end
+    end
+    NORMALIZE_PRICE_TABLE = lambda do |table|
+      (table || {}).each_with_object({}) do |(model, price), normalized|
+        normalized[model.to_s] = NORMALIZE_PRICE_ENTRY.call(price)
+      end
+    end
+    RAW_REGISTRY = JSON.parse(File.read(DEFAULT_PRICES_PATH)).freeze
+    PRICE_METADATA = RAW_REGISTRY.fetch("metadata", {}).freeze
+    BUILTIN_PRICES = NORMALIZE_PRICE_TABLE.call(RAW_REGISTRY.fetch("models", {})).freeze
+
+    private_constant :FILE_PRICES_MUTEX
+
+    class << self
+      def builtin_prices
+        BUILTIN_PRICES
+      end
+
+      def metadata
+        PRICE_METADATA
+      end
+
+      def normalize_price_table(table)
+        NORMALIZE_PRICE_TABLE.call(table)
+      end
+
+      def file_prices(path)
+        return EMPTY_PRICES unless path
+
+        path = path.to_s
+        FILE_PRICES_MUTEX.synchronize do
+          cache_key = [path, File.mtime(path).to_f]
+          return @file_prices if @file_prices_cache_key == cache_key
+
+          @file_prices_cache_key = cache_key
+          @file_prices = normalize_file_prices(price_file_models(load_price_file(path)), path: path).freeze
+        end
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError, NoMethodError => e
+        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+      end
+
+      private
+
+      def normalize_file_prices(table, path:)
+        (table || {}).each_with_object({}) do |(model, price), normalized|
+          warn_unknown_keys(model, price, path)
+          normalized[model.to_s] = normalize_price_entry(price)
+        end
+      end
+
+      def normalize_price_entry(price)
+        NORMALIZE_PRICE_ENTRY.call(price)
+      end
+
+      def warn_unknown_keys(model, price, path)
+        unknown_keys = price.keys.map(&:to_s) - PRICE_KEYS - METADATA_KEYS
+        return if unknown_keys.empty?
+
+        Logging.warn(
+          "Unknown price keys #{unknown_keys.inspect} for #{model.inspect} in #{path}; " \
+          "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}"
+        )
+      end
+
+      def load_price_file(path)
+        contents = File.read(path)
+        return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)
+
+        JSON.parse(contents)
+      end
+
+      def yaml_file?(path)
+        %w[.yaml .yml].include?(File.extname(path).downcase)
+      end
+
+      def price_file_models(registry)
+        registry.fetch("models", registry)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/prices.json

@@ -0,0 +1,51 @@
+{
+  "metadata": {
+    "updated_at": "2026-04-18",
+    "currency": "USD",
+    "unit": "1M tokens",
+    "source_urls": [
+      "https://openai.com/api/pricing",
+      "https://www.anthropic.com/pricing",
+      "https://ai.google.dev/gemini-api/docs/pricing"
+    ]
+  },
+  "models": {
+    "gpt-5.2": { "input": 1.75, "cached_input": 0.175, "output": 14.0 },
+    "gpt-5.1": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gpt-5": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gpt-5-mini": { "input": 0.25, "cached_input": 0.025, "output": 2.0 },
+    "gpt-5-nano": { "input": 0.05, "cached_input": 0.005, "output": 0.4 },
+    "gpt-4.1": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
+    "gpt-4.1-mini": { "input": 0.4, "cached_input": 0.1, "output": 1.6 },
+    "gpt-4.1-nano": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "gpt-4o-2024-05-13": { "input": 5.0, "output": 15.0 },
+    "gpt-4o": { "input": 2.5, "cached_input": 1.25, "output": 10.0 },
+    "gpt-4o-mini": { "input": 0.15, "cached_input": 0.075, "output": 0.6 },
+    "gpt-4-turbo": { "input": 10.0, "output": 30.0 },
+    "gpt-4": { "input": 30.0, "output": 60.0 },
+    "gpt-3.5-turbo": { "input": 0.5, "output": 1.5 },
+    "o1": { "input": 15.0, "cached_input": 7.5, "output": 60.0 },
+    "o1-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
+    "o3": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
+    "o3-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
+    "o4-mini": { "input": 1.1, "cached_input": 0.275, "output": 4.4 },
+    "claude-sonnet-4-6": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-opus-4-6": { "input": 5.0, "output": 25.0, "cache_read_input": 0.5, "cache_creation_input": 6.25 },
+    "claude-opus-4-1": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "claude-opus-4": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "claude-sonnet-4-5": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-sonnet-4": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-haiku-4-5": { "input": 1.0, "output": 5.0, "cache_read_input": 0.1, "cache_creation_input": 1.25 },
+    "claude-3-7-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-3-5-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-3-5-haiku": { "input": 0.8, "output": 4.0, "cache_read_input": 0.08, "cache_creation_input": 1.0 },
+    "claude-3-opus": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "gemini-2.5-pro": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gemini-2.5-flash": { "input": 0.3, "cached_input": 0.03, "output": 2.5 },
+    "gemini-2.5-flash-lite": { "input": 0.1, "cached_input": 0.01, "output": 0.4 },
+    "gemini-2.0-flash": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "gemini-2.0-flash-lite": { "input": 0.075, "output": 0.3 },
+    "gemini-1.5-pro": { "input": 1.25, "output": 5.0 },
+    "gemini-1.5-flash": { "input": 0.075, "output": 0.3 }
+  }
+}