llm_cost_tracker 0.4.1 → 0.5.0

data/lib/llm_cost_tracker/integrations/openai.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module LlmCostTracker
+  module Integrations
+    module Openai
+      extend Base
+
+      class << self
+        def integration_name = :openai
+
+        def target_patches
+          [
+            [constant("OpenAI::Resources::Responses"), ResponsesPatch],
+            [constant("OpenAI::Resources::Chat::Completions"), ChatCompletionsPatch]
+          ]
+        end
+
+        def record_response(response, request:, latency_ms:)
+          return unless active?
+
+          record_safely do
+            usage = ObjectReader.first(response, :usage)
+            next unless usage
+
+            input_tokens = ObjectReader.first(usage, :input_tokens, :prompt_tokens)
+            output_tokens = ObjectReader.first(usage, :output_tokens, :completion_tokens)
+            next if input_tokens.nil? && output_tokens.nil?
+
+            LlmCostTracker::Tracker.record(
+              provider: "openai",
+              model: ObjectReader.first(response, :model) || request[:model],
+              input_tokens: ObjectReader.integer(input_tokens),
+              output_tokens: ObjectReader.integer(output_tokens),
+              latency_ms: latency_ms,
+              usage_source: :sdk_response,
+              provider_response_id: ObjectReader.first(response, :id),
+              metadata: usage_metadata(usage)
+            )
+          end
+        end
+
+        def usage_metadata(usage)
+          {
+            cache_read_input_tokens: cache_read_input_tokens(usage),
+            hidden_output_tokens: hidden_output_tokens(usage)
+          }
+        end
+
+        def cache_read_input_tokens(usage)
+          ObjectReader.integer(
+            ObjectReader.nested(usage, :input_tokens_details, :cached_tokens) ||
+            ObjectReader.nested(usage, :prompt_tokens_details, :cached_tokens)
+          )
+        end
+
+        def hidden_output_tokens(usage)
+          ObjectReader.integer(
+            ObjectReader.nested(usage, :output_tokens_details, :reasoning_tokens) ||
+            ObjectReader.nested(usage, :completion_tokens_details, :reasoning_tokens)
+          )
+        end
+      end
+
+      module ResponsesPatch
+        def create(*args, **kwargs)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          LlmCostTracker::Integrations::Openai.enforce_budget!
+          response = super
+          LlmCostTracker::Integrations::Openai.record_response(
+            response,
+            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
+            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at)
+          )
+          response
+        end
+      end
+
+      module ChatCompletionsPatch
+        def create(*args, **kwargs)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          LlmCostTracker::Integrations::Openai.enforce_budget!
+          response = super
+          LlmCostTracker::Integrations::Openai.record_response(
+            response,
+            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
+            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at)
+          )
+          response
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/integrations/registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "openai"
+require_relative "anthropic"
+
+module LlmCostTracker
+  module Integrations
+    module Registry
+      INTEGRATIONS = {
+        openai: Openai,
+        anthropic: Anthropic
+      }.freeze
+
+      module_function
+
+      def install!(names = LlmCostTracker.configuration.instrumented_integrations)
+        normalize(names).each { |name| fetch(name).install }
+      end
+
+      def checks(names = LlmCostTracker.configuration.instrumented_integrations)
+        return [Base::Result.new(:integrations, :ok, "no SDK integrations enabled")] if names.empty?
+
+        normalize(names).map { |name| fetch(name).status }
+      end
+
+      def normalize(names)
+        Array(names).flatten.map(&:to_sym).uniq
+      end
+
+      def fetch(name)
+        INTEGRATIONS.fetch(name.to_sym) do
+          message = "Unknown integration: #{name.inspect}. Use one of: #{INTEGRATIONS.keys.join(', ')}"
+          raise LlmCostTracker::Error, message
+        end
+      end
+    end
+
+    def self.install! = Registry.install!
+    def self.checks = Registry.checks
+  end
+end

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -4,6 +4,7 @@ require "faraday"
 require "json"
 
 require_relative "../logging"
+require_relative "../request_url"
 
 module LlmCostTracker
   module Middleware
@@ -76,7 +77,7 @@ module LlmCostTracker
         response_body = read_body(response_env.body)
         unless response_body
           Logging.warn(
-            "Unable to read response body for #{request_url}; " \
+            "Unable to read response body for #{RequestUrl.label(request_url)}; " \
             "streaming responses are captured automatically for OpenAI/Anthropic/Gemini " \
             "or via LlmCostTracker.track_stream for custom clients."
           )
@@ -156,11 +157,11 @@ module LlmCostTracker
 
       def capture_warning(request_url, stream_buffer)
         unless stream_buffer&.dig(:overflowed)
-          return "Unable to capture streaming response for #{request_url}; " \
+          return "Unable to capture streaming response for #{RequestUrl.label(request_url)}; " \
                  "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
         end
 
-        "Streaming response for #{request_url} exceeded #{STREAM_CAPTURE_LIMIT_BYTES} bytes; " \
+        "Streaming response for #{RequestUrl.label(request_url)} exceeded #{STREAM_CAPTURE_LIMIT_BYTES} bytes; " \
           "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
       end
     end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -16,6 +16,7 @@ module LlmCostTracker
   )
 
   class ParsedUsage
+    UNKNOWN_MODEL = "unknown"
     TRACKING_KEYS = %i[
       provider
       model
@@ -30,7 +31,7 @@ module LlmCostTracker
     def self.build(**attributes)
       new(
         provider: attributes.fetch(:provider),
-        model: attributes.fetch(:model),
+        model: normalize_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, usage_breakdown(attributes).total_tokens).to_i,
@@ -61,5 +62,11 @@ module LlmCostTracker
       )
     end
     private_class_method :usage_breakdown
+
+    def self.normalize_model(value)
+      model = value.to_s.strip
+      model.empty? ? UNKNOWN_MODEL : model
+    end
+    private_class_method :normalize_model
   end
 end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -108,7 +108,7 @@ module LlmCostTracker
         ParsedUsage.build(
           provider: provider,
           provider_response_id: provider_response_id,
-          model: model,
+          model: model || ParsedUsage::UNKNOWN_MODEL,
           input_tokens: 0,
           output_tokens: 0,
           total_tokens: 0,

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -67,7 +67,7 @@ module LlmCostTracker
       end
 
       def detect_stream_model(events)
-        find_event_value(events) { |data| data["model"] }
+        find_event_value(events) { |data| data["model"] || data.dig("response", "model") }
       end
 
       def detect_stream_response_id(events)

data/lib/llm_cost_tracker/price_freshness.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "date"
+
+module LlmCostTracker
+  module PriceFreshness
+    STALE_AFTER_DAYS = 30
+
+    class << self
+      def call(metadata, today: Date.today)
+        updated_at = metadata["updated_at"] || metadata[:updated_at]
+        return missing unless updated_at
+
+        date = Date.iso8601(updated_at.to_s)
+        age_days = (today - date).to_i
+        return stale(updated_at) if age_days > STALE_AFTER_DAYS
+
+        [:ok, "updated_at=#{updated_at}"]
+      rescue Date::Error
+        [:warn, "metadata.updated_at=#{updated_at.inspect} is invalid; run bin/rails llm_cost_tracker:prices:sync"]
+      end
+
+      private
+
+      def missing
+        [:warn, "metadata.updated_at missing; run bin/rails llm_cost_tracker:prices:sync"]
+      end
+
+      def stale(updated_at)
+        [
+          :warn,
+          "updated_at=#{updated_at} is older than #{STALE_AFTER_DAYS} days; " \
+          "run bin/rails llm_cost_tracker:prices:sync"
+        ]
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_registry.rb

@@ -25,6 +25,20 @@ module LlmCostTracker
         @metadata ||= MUTEX.synchronize { @metadata || raw_registry.fetch("metadata", {}).freeze }
       end
 
+      def file_metadata(path)
+        return {} unless path
+
+        registry = load_price_file(path.to_s)
+        raise ArgumentError, "prices_file must be a hash" unless registry.is_a?(Hash)
+
+        metadata = registry.fetch("metadata", {})
+        raise ArgumentError, "prices_file metadata must be a hash" unless metadata.is_a?(Hash)
+
+        metadata
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+      end
+
       def normalize_price_table(table)
         normalize_price_entries(table, context: "price table")
       end

data/lib/llm_cost_tracker/price_sync/fetcher.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require "net/http"
+require "openssl"
 require "time"
 require "uri"
 
@@ -52,7 +53,7 @@ module LlmCostTracker
         else
           raise Error, "Unable to fetch #{url}: HTTP #{response.code}"
         end
-      rescue SocketError, SystemCallError, Timeout::Error => e
+      rescue OpenSSL::SSL::SSLError, SocketError, SystemCallError, Timeout::Error => e
         raise Error, "Unable to fetch #{url}: #{e.class}: #{e.message}"
       end
 

data/lib/llm_cost_tracker/price_sync/refresh_plan_builder.rb

@@ -31,7 +31,7 @@ module LlmCostTracker
           ),
           accepted: validated.accepted,
           changes: price_changes(current_models, updated_models),
-          orphaned_models: compute_orphaned(current_models, merged.keys),
+          orphaned_models: compute_orphaned(current_models, merged.keys, source_results),
           failed_sources: failed_sources,
           discrepancies: discrepancies,
           rejected: validated.rejected,
@@ -70,7 +70,9 @@ module LlmCostTracker
         merged.sort.to_h
       end
 
-      def compute_orphaned(current_models, merged_models)
+      def compute_orphaned(current_models, merged_models, source_results)
+        return [] if source_results.empty?
+
         seed_models(current_models).keys.reject do |model|
           manual_model?(current_models[model]) || merged_models.include?(model)
         end.sort

data/lib/llm_cost_tracker/price_sync.rb

@@ -67,6 +67,16 @@ module LlmCostTracker
     end
 
     class << self
+      def configured_output_path(env: ENV, config: LlmCostTracker.configuration)
+        output = env["OUTPUT"].to_s.strip
+        return output unless output.empty?
+
+        prices_file = config.prices_file
+        return prices_file.to_s if prices_file
+
+        nil
+      end
+
       def sync(path: DEFAULT_OUTPUT_PATH, seed_path: DEFAULT_OUTPUT_PATH, preview: false, strict: false,
                fetcher: Fetcher.new, today: Date.today)
         plan = RefreshPlanBuilder.new(sources: sources).call(