llm_cost_tracker 0.1.1 → 0.1.2

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 }
+  }
+}

data/lib/llm_cost_tracker/pricing.rb

@@ -2,52 +2,8 @@
 
 module LlmCostTracker
   # Prices per 1M tokens in USD.
-  # Updated: April 2026. Override via configuration.
   module Pricing
-    PRICES = {
-      # OpenAI
-      "gpt-5.2"            => { input: 1.75,  cached_input: 0.175, output: 14.00 },
-      "gpt-5.1"            => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gpt-5"              => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gpt-5-mini"         => { input: 0.25,  cached_input: 0.025, output: 2.00 },
-      "gpt-5-nano"         => { input: 0.05,  cached_input: 0.005, output: 0.40 },
-      "gpt-4.1"            => { input: 2.00,  cached_input: 0.50,  output: 8.00 },
-      "gpt-4.1-mini"       => { input: 0.40,  cached_input: 0.10,  output: 1.60 },
-      "gpt-4.1-nano"       => { input: 0.10,  cached_input: 0.025, output: 0.40 },
-      "gpt-4o-2024-05-13"  => { input: 5.00,  output: 15.00 },
-      "gpt-4o"             => { input: 2.50,  cached_input: 1.25,  output: 10.00 },
-      "gpt-4o-mini"        => { input: 0.15,  cached_input: 0.075, output: 0.60 },
-      "gpt-4-turbo"        => { input: 10.00, output: 30.00 },
-      "gpt-4"              => { input: 30.00, output: 60.00 },
-      "gpt-3.5-turbo"      => { input: 0.50,  output: 1.50 },
-      "o1"                 => { input: 15.00, cached_input: 7.50,  output: 60.00 },
-      "o1-mini"            => { input: 1.10,  cached_input: 0.55,  output: 4.40 },
-      "o3"                 => { input: 2.00,  cached_input: 0.50,  output: 8.00 },
-      "o3-mini"            => { input: 1.10,  cached_input: 0.55,  output: 4.40 },
-      "o4-mini"            => { input: 1.10,  cached_input: 0.275, output: 4.40 },
-
-      # Anthropic
-      "claude-sonnet-4-6"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-opus-4-6"    => { input: 5.00,  output: 25.00, cache_read_input: 0.50, cache_creation_input: 6.25 },
-      "claude-opus-4-1"    => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-      "claude-opus-4"      => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-      "claude-sonnet-4-5"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-sonnet-4"    => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-haiku-4-5"   => { input: 1.00,  output: 5.00,  cache_read_input: 0.10, cache_creation_input: 1.25 },
-      "claude-3-7-sonnet"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-3-5-sonnet"  => { input: 3.00,  output: 15.00, cache_read_input: 0.30, cache_creation_input: 3.75 },
-      "claude-3-5-haiku"   => { input: 0.80,  output: 4.00,  cache_read_input: 0.08, cache_creation_input: 1.00 },
-      "claude-3-opus"      => { input: 15.00, output: 75.00, cache_read_input: 1.50, cache_creation_input: 18.75 },
-
-      # Google Gemini
-      "gemini-2.5-pro"     => { input: 1.25,  cached_input: 0.125, output: 10.00 },
-      "gemini-2.5-flash"   => { input: 0.30,  cached_input: 0.03,  output: 2.50 },
-      "gemini-2.5-flash-lite" => { input: 0.10, cached_input: 0.01, output: 0.40 },
-      "gemini-2.0-flash" => { input: 0.10, cached_input: 0.025, output: 0.40 },
-      "gemini-2.0-flash-lite" => { input: 0.075, output: 0.30 },
-      "gemini-1.5-pro"     => { input: 1.25,  output: 5.00 },
-      "gemini-1.5-flash"   => { input: 0.075, output: 0.30 }
-    }.freeze
+    PRICES = PriceRegistry.builtin_prices
 
     class << self
       def cost_for(model:, input_tokens:, output_tokens:, cached_input_tokens: 0,
@@ -55,54 +11,98 @@ module LlmCostTracker
         prices = lookup(model)
         return nil unless prices
 
-        cached_input_tokens = cached_input_tokens.to_i
-        cache_read_input_tokens = cache_read_input_tokens.to_i
-        cache_creation_input_tokens = cache_creation_input_tokens.to_i
-        uncached_input_tokens = [input_tokens.to_i - cached_input_tokens, 0].max
-
-        input_cost = (uncached_input_tokens.to_f / 1_000_000) * prices[:input]
-        cached_input_cost = (cached_input_tokens.to_f / 1_000_000) *
-                            (prices[:cached_input] || prices[:input])
-        cache_read_input_cost = (cache_read_input_tokens.to_f / 1_000_000) *
-                                (prices[:cache_read_input] || prices[:cached_input] || prices[:input])
-        cache_creation_input_cost = (cache_creation_input_tokens.to_f / 1_000_000) *
-                                    (prices[:cache_creation_input] || prices[:input])
-        output_cost = (output_tokens.to_f / 1_000_000) * prices[:output]
-        total_cost = input_cost + cached_input_cost + cache_read_input_cost +
-                     cache_creation_input_cost + output_cost
+        token_counts = normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                               cache_read_input_tokens, cache_creation_input_tokens)
+        costs = calculate_costs(token_counts, prices)
 
         {
-          input_cost: input_cost.round(8),
-          cached_input_cost: cached_input_cost.round(8),
-          cache_read_input_cost: cache_read_input_cost.round(8),
-          cache_creation_input_cost: cache_creation_input_cost.round(8),
-          output_cost: output_cost.round(8),
-          total_cost: total_cost.round(8),
+          input_cost: costs[:input].round(8),
+          cached_input_cost: costs[:cached_input].round(8),
+          cache_read_input_cost: costs[:cache_read_input].round(8),
+          cache_creation_input_cost: costs[:cache_creation_input].round(8),
+          output_cost: costs[:output].round(8),
+          total_cost: costs.values.sum.round(8),
           currency: "USD"
         }
       end
 
       def lookup(model)
-        overrides = LlmCostTracker.configuration.pricing_overrides
-        overrides[model] || PRICES[model] || fuzzy_match(model)
+        table = prices
+        model_name = model.to_s
+        normalized_model = normalize_model_name(model_name)
+
+        table[model_name] || table[normalized_model] || fuzzy_match(model_name, normalized_model, table)
       end
 
       def models
-        PRICES.keys | LlmCostTracker.configuration.pricing_overrides.keys
+        prices.keys
+      end
+
+      def metadata
+        PriceRegistry.metadata
+      end
+
+      def prices
+        PRICES
+          .merge(PriceRegistry.file_prices(LlmCostTracker.configuration.prices_file))
+          .merge(PriceRegistry.normalize_price_table(LlmCostTracker.configuration.pricing_overrides))
       end
 
       private
 
-      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o"
-      def fuzzy_match(model)
-        return nil unless model
+      def normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                  cache_read_input_tokens, cache_creation_input_tokens)
+        cached_input_tokens = cached_input_tokens.to_i
+
+        {
+          input: [input_tokens.to_i - cached_input_tokens, 0].max,
+          cached_input: cached_input_tokens,
+          cache_read_input: cache_read_input_tokens.to_i,
+          cache_creation_input: cache_creation_input_tokens.to_i,
+          output: output_tokens.to_i
+        }
+      end
+
+      def calculate_costs(token_counts, prices)
+        {
+          input: token_cost(token_counts[:input], prices[:input]),
+          cached_input: token_cost(token_counts[:cached_input], prices[:cached_input] || prices[:input]),
+          cache_read_input: token_cost(
+            token_counts[:cache_read_input],
+            prices[:cache_read_input] || prices[:cached_input] || prices[:input]
+          ),
+          cache_creation_input: token_cost(
+            token_counts[:cache_creation_input],
+            prices[:cache_creation_input] || prices[:input]
+          ),
+          output: token_cost(token_counts[:output], prices[:output])
+        }
+      end
+
+      def token_cost(tokens, per_million_price)
+        (tokens.to_f / 1_000_000) * per_million_price
+      end
 
-        PRICES.sort_by { |key, _value| -key.length }.each do |key, value|
-          return value if model.start_with?(key)
+      def normalize_model_name(model)
+        model.to_s.split("/").last
+      end
+
+      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o".
+      def fuzzy_match(model, normalized_model, table)
+        sorted_price_keys(table).each do |key|
+          return table[key] if model.start_with?(key) || normalized_model.start_with?(key)
         end
 
         nil
       end
+
+      def sorted_price_keys(table)
+        cache_key = table.keys
+        return @sorted_price_keys if @sorted_price_keys_cache_key == cache_key
+
+        @sorted_price_keys_cache_key = cache_key
+        @sorted_price_keys = cache_key.sort_by { |key| -key.length }
+      end
     end
   end
 end

data/lib/llm_cost_tracker/railtie.rb

@@ -3,7 +3,10 @@
 module LlmCostTracker
   class Railtie < Rails::Railtie
     generators do
+      require_relative "generators/llm_cost_tracker/add_latency_ms_generator"
       require_relative "generators/llm_cost_tracker/install_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_cost_precision_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_tags_to_jsonb_generator"
     end
 
     initializer "llm_cost_tracker.configure" do

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -5,7 +5,9 @@ module LlmCostTracker
     class ActiveRecordStore
       class << self
         def save(event)
-          model_class.create!(
+          tags = stringify_tags(event[:tags] || {})
+
+          attributes = {
             provider:      event[:provider],
             model:         event[:model],
             input_tokens:  event[:input_tokens],
@@ -14,9 +16,12 @@ module LlmCostTracker
             input_cost:    event.dig(:cost, :input_cost),
             output_cost:   event.dig(:cost, :output_cost),
             total_cost:    event.dig(:cost, :total_cost),
-            tags:          stringify_tags(event[:tags]).to_json,
+            tags:          tags_for_storage(tags),
             tracked_at:    event[:tracked_at]
-          )
+          }
+          attributes[:latency_ms] = event[:latency_ms] if model_class.latency_column?
+
+          model_class.create!(attributes)
         end
 
         def monthly_total(time: Time.now.utc)
@@ -38,6 +43,10 @@ module LlmCostTracker
           tags.transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
         end
 
+        def tags_for_storage(tags)
+          model_class.tags_json_column? ? tags : tags.to_json
+        end
+
         def stringify_tag_value(value)
           return value.transform_values { |nested| stringify_tag_value(nested) } if value.is_a?(Hash)
 

data/lib/llm_cost_tracker/tracker.rb

@@ -5,8 +5,12 @@ module LlmCostTracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
     class << self
-      def record(provider:, model:, input_tokens:, output_tokens:, metadata: {})
-        usage = usage_data(input_tokens, output_tokens, metadata)
+      def enforce_budget!
+        Budget.enforce!
+      end
+
+      def record(provider:, model:, input_tokens:, output_tokens:, metadata: {}, latency_ms: nil)
+        usage = EventMetadata.usage_data(input_tokens, output_tokens, metadata)
 
         cost_data = Pricing.cost_for(
           model: model,
@@ -17,6 +21,8 @@ module LlmCostTracker
           cache_creation_input_tokens: usage[:cache_creation_input_tokens]
         )
 
+        UnknownPricing.handle!(model) unless cost_data
+
         event = {
           provider: provider,
           model: model,
@@ -24,7 +30,8 @@ module LlmCostTracker
           output_tokens: usage[:output_tokens],
           total_tokens: usage[:total_tokens],
           cost: cost_data,
-          tags: LlmCostTracker.configuration.default_tags.merge(metadata),
+          tags: LlmCostTracker.configuration.default_tags.merge(EventMetadata.tags(metadata)),
+          latency_ms: normalized_latency_ms(latency_ms),
           tracked_at: Time.now.utc
         }
 
@@ -32,10 +39,8 @@ module LlmCostTracker
         ActiveSupport::Notifications.instrument(EVENT_NAME, event)
 
         # Store based on backend
-        store(event)
-
-        # Budget check
-        check_budget(event)
+        stored = store(event)
+        Budget.check!(event) unless stored == false
 
         event
       end
@@ -53,6 +58,13 @@ module LlmCostTracker
         when :custom
           config.custom_storage&.call(event)
         end
+
+        true
+      rescue BudgetExceededError, UnknownPricingError
+        raise
+      rescue StandardError => e
+        handle_storage_error(e)
+        false
       end
 
       def log_event(event)
@@ -61,6 +73,7 @@ module LlmCostTracker
         message = "[LlmCostTracker] #{event[:provider]}/#{event[:model]} " \
                   "tokens=#{event[:input_tokens]}+#{event[:output_tokens]} " \
                   "cost=#{cost_str}"
+        message += " latency=#{event[:latency_ms]}ms" if event[:latency_ms]
         message += " tags=#{event[:tags]}" unless event[:tags].empty?
 
         case LlmCostTracker.configuration.log_level
@@ -76,6 +89,16 @@ module LlmCostTracker
         warn(message) unless defined?(Rails)
       end
 
+      def log_warning(message)
+        message = "[LlmCostTracker] #{message}"
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn(message)
+        else
+          warn message
+        end
+      end
+
       def store_active_record(event)
         require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
         require_relative "storage/active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
@@ -85,59 +108,31 @@ module LlmCostTracker
         raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
       end
 
-      def check_budget(event)
-        config = LlmCostTracker.configuration
-        return unless config.monthly_budget && config.on_budget_exceeded
-        return unless event[:cost]
-
-        monthly_total = calculate_monthly_total(event[:cost][:total_cost])
-        return unless monthly_total > config.monthly_budget
-
-        config.on_budget_exceeded.call(
-          monthly_total: monthly_total,
-          budget: config.monthly_budget,
-          last_event: event
-        )
-      end
-
-      def calculate_monthly_total(latest_cost)
-        # For :active_record backend, query the DB
-        if LlmCostTracker.configuration.active_record? &&
-           defined?(LlmCostTracker::Storage::ActiveRecordStore)
-          LlmCostTracker::Storage::ActiveRecordStore.monthly_total
-        else
-          # For other backends, we can only report the latest cost
-          latest_cost
+      def handle_storage_error(error)
+        case storage_error_behavior
+        when :ignore
+          nil
+        when :warn
+          log_warning("Storage failed; tracking event was not persisted: #{error.class}: #{error.message}")
+        when :raise
+          storage_error = StorageError.new(error)
+          raise storage_error
         end
       end
 
-      def usage_data(input_tokens, output_tokens, metadata)
-        cache_read_input_tokens = integer_metadata(metadata, :cache_read_input_tokens, :cache_read_tokens)
-        cache_creation_input_tokens = integer_metadata(
-          metadata,
-          :cache_creation_input_tokens,
-          :cache_creation_tokens
-        )
-        cached_input_tokens = integer_metadata(metadata, :cached_input_tokens)
-
-        {
-          input_tokens: input_tokens.to_i,
-          output_tokens: output_tokens.to_i,
-          cached_input_tokens: cached_input_tokens,
-          cache_read_input_tokens: cache_read_input_tokens,
-          cache_creation_input_tokens: cache_creation_input_tokens,
-          total_tokens: input_tokens.to_i + output_tokens.to_i +
-            cache_read_input_tokens + cache_creation_input_tokens
-        }
+      def storage_error_behavior
+        behavior = (LlmCostTracker.configuration.storage_error_behavior || :warn).to_sym
+        return behavior if Configuration::STORAGE_ERROR_BEHAVIORS.include?(behavior)
+
+        raise Error,
+              "Unknown storage_error_behavior: #{behavior.inspect}. " \
+              "Use one of: #{Configuration::STORAGE_ERROR_BEHAVIORS.join(', ')}"
       end
 
-      def integer_metadata(metadata, *keys)
-        keys.each do |key|
-          value = metadata[key] || metadata[key.to_s]
-          return value.to_i unless value.nil?
-        end
+      def normalized_latency_ms(latency_ms)
+        return nil if latency_ms.nil?
 
-        0
+        [latency_ms.to_i, 0].max
       end
     end
   end

data/lib/llm_cost_tracker/unknown_pricing.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class UnknownPricing
+    class << self
+      def handle!(model)
+        model = normalized_model_name(model)
+
+        case behavior
+        when :ignore
+          nil
+        when :warn
+          warn_missing(model)
+        when :raise
+          raise UnknownPricingError.new(model: model)
+        end
+      end
+
+      private
+
+      def normalized_model_name(model)
+        model.to_s.empty? ? "unknown" : model.to_s
+      end
+
+      def warn_missing(model)
+        message = "[LlmCostTracker] No pricing configured for model #{model.inspect}. " \
+                  "Cost and budget enforcement will be skipped for this event. " \
+                  "Add a pricing_overrides entry or set unknown_pricing_behavior."
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn(message)
+        else
+          Kernel.warn(message)
+        end
+      end
+
+      def behavior
+        behavior = (LlmCostTracker.configuration.unknown_pricing_behavior || :warn).to_sym
+        return behavior if Configuration::UNKNOWN_PRICING_BEHAVIORS.include?(behavior)
+
+        raise Error,
+              "Unknown unknown_pricing_behavior: #{behavior.inspect}. " \
+              "Use one of: #{Configuration::UNKNOWN_PRICING_BEHAVIORS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/version.rb

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

data/lib/llm_cost_tracker.rb

@@ -5,31 +5,39 @@ require "active_support/notifications"
 
 require_relative "llm_cost_tracker/version"
 require_relative "llm_cost_tracker/configuration"
+require_relative "llm_cost_tracker/errors"
+require_relative "llm_cost_tracker/price_registry"
 require_relative "llm_cost_tracker/pricing"
 require_relative "llm_cost_tracker/parsers/base"
 require_relative "llm_cost_tracker/parsers/openai"
+require_relative "llm_cost_tracker/parsers/openai_compatible"
 require_relative "llm_cost_tracker/parsers/anthropic"
 require_relative "llm_cost_tracker/parsers/gemini"
 require_relative "llm_cost_tracker/parsers/registry"
 require_relative "llm_cost_tracker/middleware/faraday"
+require_relative "llm_cost_tracker/budget"
+require_relative "llm_cost_tracker/unknown_pricing"
+require_relative "llm_cost_tracker/event_metadata"
 require_relative "llm_cost_tracker/tracker"
 
 module LlmCostTracker
-  class Error < StandardError; end
-
   class << self
+    CONFIGURATION_MUTEX = Mutex.new
+
     attr_writer :configuration
 
     def configuration
-      @configuration ||= Configuration.new
+      @configuration || CONFIGURATION_MUTEX.synchronize { @configuration ||= Configuration.new }
     end
 
     def configure
       yield(configuration)
+      configuration.normalize_openai_compatible_providers!
+      warn_for_configuration!
     end
 
     def reset_configuration!
-      @configuration = Configuration.new
+      CONFIGURATION_MUTEX.synchronize { @configuration = Configuration.new }
     end
 
     # Manual tracking for non-Faraday clients
@@ -42,15 +50,35 @@ module LlmCostTracker
     #     feature: "chat",
     #     user_id: current_user.id
     #   )
-    def track(provider:, model:, input_tokens:, output_tokens:, **metadata)
+    def track(provider:, model:, input_tokens:, output_tokens:, latency_ms: nil, **metadata)
       Tracker.record(
         provider: provider.to_s,
         model: model,
         input_tokens: input_tokens,
         output_tokens: output_tokens,
+        latency_ms: latency_ms,
         metadata: metadata
       )
     end
+
+    private
+
+    def warn_for_configuration!
+      return unless (configuration.budget_exceeded_behavior || :notify).to_sym == :block_requests
+      return if configuration.active_record?
+
+      log_warning(":block_requests requires storage_backend = :active_record; preflight blocking will be skipped.")
+    end
+
+    def log_warning(message)
+      message = "[LlmCostTracker] #{message}"
+
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.warn(message)
+      else
+        warn message
+      end
+    end
   end
 end
 

data/llm_cost_tracker.gemspec

@@ -8,10 +8,11 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Sergii Khomenko"]
   spec.email         = ["sergey@mm.st"]
 
-  spec.summary       = "Self-hosted LLM API cost tracking for Ruby and Rails"
-  spec.description   = "Tracks token usage and estimated costs for OpenAI, Anthropic, and Google Gemini calls. " \
+  spec.summary       = "Self-hosted LLM API cost guardrails for Ruby and Rails"
+  spec.description   = "Tracks token usage and estimated costs for OpenAI, Anthropic, Google Gemini, " \
+                       "OpenRouter, DeepSeek, and OpenAI-compatible calls. " \
                        "Works as Faraday middleware for Ruby clients, with ActiveRecord storage, " \
-                       "per-user/per-feature attribution, and budget alerts."
+                       "per-user/per-feature attribution, budget alerts, and budget enforcement."
   spec.homepage      = "https://github.com/sergey-homenko/llm_cost_tracker"
   spec.license       = "MIT"