llm_cost_tracker 0.5.1 → 0.5.3

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -54,8 +54,34 @@ module LlmCostTracker
           ActiveRecordRollups.period_totals(periods, time: time)
         end
 
+        def prune(cutoff:, batch_size:)
+          deleted = 0
+          loop do
+            batch = prune_batch(cutoff, batch_size)
+            deleted += batch
+            break if batch < batch_size
+          end
+          deleted
+        end
+
         private
 
+        def prune_batch(cutoff, batch_size)
+          LlmCostTracker::LlmApiCall.transaction do
+            rows = LlmCostTracker::LlmApiCall
+                   .where(tracked_at: ...cutoff)
+                   .order(:id)
+                   .limit(batch_size)
+                   .lock
+                   .pluck(:id, :tracked_at, :total_cost)
+            next 0 if rows.empty?
+
+            deleted = LlmCostTracker::LlmApiCall.where(id: rows.map(&:first)).delete_all
+            ActiveRecordRollups.decrement!(rows) if deleted.positive?
+            deleted
+          end
+        end
+
         def stringify_tags(tags)
           tags.transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
         end

data/lib/llm_cost_tracker/storage/custom_backend.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+
+module LlmCostTracker
+  module Storage
+    class CustomBackend
+      class << self
+        def save(event)
+          result = LlmCostTracker.configuration.custom_storage&.call(event)
+          result == false ? false : event
+        end
+
+        def verify
+          if LlmCostTracker.configuration.custom_storage.respond_to?(:call)
+            return [
+              VerificationResult.new(
+                :ok,
+                "storage",
+                "custom storage callable configured; external sink was not invoked"
+              )
+            ]
+          end
+
+          [
+            VerificationResult.new(:error, "storage", "custom storage backend requires config.custom_storage")
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/dispatcher.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "../logging"
+require_relative "registry"
+require_relative "active_record_backend"
+require_relative "custom_backend"
+require_relative "log_backend"
 
 module LlmCostTracker
   module Storage
     class Dispatcher
       class << self
         def save(event)
-          config = LlmCostTracker.configuration
-          case config.storage_backend
-          when :log           then log_event(event, config)
-          when :active_record then active_record_save(event)
-          when :custom        then custom_save(event, config)
-          end
+          backend.save(event)
         rescue LlmCostTracker::BudgetExceededError, LlmCostTracker::UnknownPricingError
           raise
         rescue StandardError => e
@@ -22,34 +21,8 @@ module LlmCostTracker
 
         private
 
-        def log_event(event, config)
-          message = "#{event.provider}/#{event.model} " \
-                    "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
-          message += " source=#{event.usage_source}" if event.usage_source
-          message += " tags=#{event.tags}" unless event.tags.empty?
-
-          Logging.log(config.log_level, message)
-          event
-        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)
-          require_relative "active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
-
-          ActiveRecordStore.save(event)
-          event
-        rescue LoadError => e
-          raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
-        end
-
-        def custom_save(event, config)
-          result = config.custom_storage&.call(event)
-          result == false ? false : event
+        def backend
+          Registry.fetch(LlmCostTracker.configuration.storage_backend)
         end
 
         def handle_error(error)
@@ -64,5 +37,9 @@ module LlmCostTracker
         end
       end
     end
+
+    Registry.register(:log, LogBackend)
+    Registry.register(:active_record, ActiveRecordBackend)
+    Registry.register(:custom, CustomBackend)
   end
 end

data/lib/llm_cost_tracker/storage/log_backend.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../logging"
+require_relative "registry"
+
+module LlmCostTracker
+  module Storage
+    class LogBackend
+      class << self
+        def save(event)
+          config = LlmCostTracker.configuration
+          message = "#{event.provider}/#{event.model} " \
+                    "tokens=#{event.total_tokens} " \
+                    "cost=#{cost_label(event)}"
+          message += " latency=#{event.latency_ms}ms" if event.latency_ms
+          message += " stream=#{event.stream}" if event.stream
+          message += " source=#{event.usage_source}" if event.usage_source
+          message += " tags=#{event.tags}" unless event.tags.empty?
+
+          Logging.log(config.log_level, message)
+          event
+        end
+
+        def verify
+          [
+            VerificationResult.new(:ok, "storage", "log backend configured; capture writes to logs only")
+          ]
+        end
+
+        private
+
+        def cost_label(event)
+          event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+require_relative "../errors"
+
+module LlmCostTracker
+  module Storage
+    VerificationResult = Data.define(:status, :name, :message)
+
+    module Registry
+      MUTEX = Monitor.new
+
+      class << self
+        def register(name, backend)
+          name = normalize_name(name)
+          validate_backend!(backend)
+          MUTEX.synchronize { @backends = backends.merge(name => backend).freeze }
+          backend
+        end
+
+        def fetch(name)
+          key = normalize_name(name)
+          backends.fetch(key) do
+            raise Error, "Unknown storage_backend: #{key.inspect}. Use one of: #{names.join(', ')}"
+          end
+        end
+
+        def registered?(name)
+          backends.key?(normalize_name(name))
+        end
+
+        def names
+          backends.keys
+        end
+
+        private
+
+        def backends
+          @backends || MUTEX.synchronize { @backends ||= {}.freeze }
+        end
+
+        def normalize_name(name)
+          name.to_sym
+        end
+
+        def validate_backend!(backend)
+          return if backend.respond_to?(:save)
+
+          raise ArgumentError, "storage backend must respond to save"
+        end
+      end
+    end
+
+    def self.register(name, backend)
+      Registry.register(name, backend)
+    end
+
+    def self.backends
+      Registry.names
+    end
+  end
+end

data/lib/llm_cost_tracker/stream_capture.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module StreamCapture
+    LIMIT_BYTES = 1_048_576
+  end
+end

data/lib/llm_cost_tracker/stream_collector.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "json"
 require "monitor"
 
+require_relative "stream_capture"
 require_relative "value_helpers"
 
 module LlmCostTracker
@@ -16,6 +18,8 @@ module LlmCostTracker
       @pricing_mode = pricing_mode
       @metadata = ValueHelpers.deep_dup(metadata || {})
       @events = []
+      @captured_bytes = 0
+      @overflowed = false
       @explicit_usage = nil
       @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @finished = false
@@ -45,7 +49,7 @@ module LlmCostTracker
     def event(data, type: nil)
       @monitor.synchronize do
         ensure_open!
-        @events << { event: type, data: ValueHelpers.deep_dup(data) } unless data.nil?
+        capture_event(data, type: type) unless data.nil?
       end
       self
     end
@@ -71,6 +75,7 @@ module LlmCostTracker
         @finished = true
         {
           events: @events.dup,
+          overflowed: @overflowed,
           explicit_usage: ValueHelpers.deep_dup(@explicit_usage),
           model: @model,
           latency_ms: @latency_ms,
@@ -105,6 +110,7 @@ module LlmCostTracker
 
     def build_parsed_usage(snapshot)
       return build_from_explicit_usage(snapshot) if snapshot[:explicit_usage]
+      return build_unknown_usage(snapshot) if snapshot[:overflowed]
 
       parsed = Parsers::Registry.find_for_provider(@provider)&.parse_stream(nil, nil, 200, snapshot[:events])
       return finalize(parsed, snapshot) if parsed
@@ -157,6 +163,24 @@ module LlmCostTracker
       )
     end
 
+    def capture_event(data, type:)
+      copied = ValueHelpers.deep_dup(data)
+      size = event_bytes(copied, type)
+      if @captured_bytes + size <= StreamCapture::LIMIT_BYTES
+        @events << { event: type, data: copied }
+        @captured_bytes += size
+      else
+        @overflowed = true
+        @events.clear
+      end
+    end
+
+    def event_bytes(data, type)
+      JSON.generate(event: type, data: data).bytesize
+    rescue JSON::GeneratorError, TypeError
+      type.to_s.bytesize + data.to_s.bytesize
+    end
+
     def error_metadata(errored) = errored ? { stream_errored: true } : {}
 
     def elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at) * 1000).round

data/lib/llm_cost_tracker/tag_sanitizer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LlmCostTracker
+  module TagSanitizer
+    REDACTED_VALUE = "[REDACTED]"
+
+    class << self
+      def call(tags, config: LlmCostTracker.configuration)
+        tags = (tags || {}).to_h
+        tags.first(max_tag_count(config)).each_with_object({}) do |(key, value), sanitized|
+          sanitized[key] = sanitized_value(key, value, config)
+        end
+      end
+
+      private
+
+      def sanitized_value(key, value, config)
+        return REDACTED_VALUE if redacted_key?(key, config)
+
+        string = value_string(value)
+        return value if string.bytesize <= max_tag_value_bytesize(config)
+
+        truncate_bytes(string, max_tag_value_bytesize(config))
+      end
+
+      def redacted_key?(key, config)
+        normalized = normalized_key(key)
+        redacted_keys(config).any? do |candidate|
+          redacted_key_component?(normalized, candidate)
+        end
+      end
+
+      def redacted_keys(config)
+        Array(config.redacted_tag_keys).map { |key| normalized_key(key) }
+      end
+
+      def normalized_key(key)
+        key.to_s
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+           .gsub(/[^a-z0-9]+/, "_")
+           .gsub(/_+/, "_")
+           .delete_prefix("_")
+           .delete_suffix("_")
+      end
+
+      def redacted_key_component?(key, candidate)
+        key == candidate ||
+          key.start_with?("#{candidate}_") ||
+          key.end_with?("_#{candidate}") ||
+          key.include?("_#{candidate}_")
+      end
+
+      def value_string(value)
+        case value
+        when Hash, Array
+          JSON.generate(value)
+        else
+          value.to_s
+        end
+      rescue JSON::GeneratorError, TypeError
+        value.to_s
+      end
+
+      def truncate_bytes(string, limit)
+        string.byteslice(0, limit).to_s.encode("UTF-8", invalid: :replace, undef: :replace)
+      end
+
+      def max_tag_count(config)
+        [config.max_tag_count.to_i, 0].max
+      end
+
+      def max_tag_value_bytesize(config)
+        [config.max_tag_value_bytesize.to_i, 0].max
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tag_sql.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "tag_key"
+
+module LlmCostTracker
+  module TagSql
+    class << self
+      def value_expression(model, key, table_name:)
+        key = TagKey.validate!(key)
+        column = "#{table_name}.#{model.connection.quote_column_name('tags')}"
+
+        case model.connection.adapter_name
+        when /postgres/i
+          json_column = model.tags_jsonb_column? ? column : "(#{column})::jsonb"
+          "#{json_column}->>#{model.connection.quote(key)}"
+        when /mysql/i
+          "JSON_UNQUOTE(JSON_EXTRACT(#{column}, #{model.connection.quote(json_path(key))}))"
+        else
+          "json_extract(#{column}, #{model.connection.quote(json_path(key))})"
+        end
+      end
+
+      def value_label(value)
+        value.nil? || value == "" ? "(untagged)" : value.to_s
+      end
+
+      private
+
+      def json_path(key)
+        "$.\"#{key}\""
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tracker.rb

@@ -6,7 +6,7 @@ module LlmCostTracker
   class Tracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
-    USAGE_SOURCES = %i[response stream_final sdk_response manual unknown].freeze
+    USAGE_SOURCES = %i[response stream_final sdk_response ruby_llm manual unknown].freeze
 
     class << self
       def enforce_budget!
@@ -84,7 +84,7 @@ module LlmCostTracker
           hidden_output_tokens: usage[:hidden_output_tokens],
           pricing_mode: usage[:pricing_mode],
           cost: cost_data,
-          tags: LlmCostTracker::TagContext.tags.merge(EventMetadata.tags(metadata)).freeze,
+          tags: sanitized_tags(metadata).freeze,
           latency_ms: normalized_latency_ms(latency_ms),
           stream: stream ? true : false,
           usage_source: normalized_usage_source(usage_source),
@@ -95,6 +95,10 @@ module LlmCostTracker
 
       def normalized_latency_ms(latency_ms) = latency_ms.nil? ? nil : [latency_ms.to_i, 0].max
 
+      def sanitized_tags(metadata)
+        LlmCostTracker::TagSanitizer.call(LlmCostTracker::TagContext.tags.merge(EventMetadata.tags(metadata)))
+      end
+
       def normalized_usage_source(value)
         return nil if value.nil?
 

data/lib/llm_cost_tracker/version.rb

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

data/lib/llm_cost_tracker.rb

@@ -30,16 +30,20 @@ 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/tag_context"
+require_relative "llm_cost_tracker/tag_sanitizer"
 require_relative "llm_cost_tracker/tags_column"
 require_relative "llm_cost_tracker/tag_key"
+require_relative "llm_cost_tracker/tag_sql"
 require_relative "llm_cost_tracker/tag_query"
 require_relative "llm_cost_tracker/tag_accessors"
+require_relative "llm_cost_tracker/llm_api_call_metrics"
 require_relative "llm_cost_tracker/tracker"
 require_relative "llm_cost_tracker/retention"
 require_relative "llm_cost_tracker/report_data"
 require_relative "llm_cost_tracker/report_formatter"
 require_relative "llm_cost_tracker/report"
 require_relative "llm_cost_tracker/doctor"
+require_relative "llm_cost_tracker/capture_verifier"
 
 module LlmCostTracker
   CONFIGURATION_MUTEX = Monitor.new

data/lib/tasks/llm_cost_tracker.rake

@@ -7,11 +7,21 @@ namespace :llm_cost_tracker do
   desc "Check LLM Cost Tracker setup"
   task :doctor do
     Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
+    require_relative "../llm_cost_tracker"
     checks = LlmCostTracker::Doctor.call
     puts LlmCostTracker::Doctor.report(checks)
     abort("llm_cost_tracker: doctor found setup errors") unless LlmCostTracker::Doctor.healthy?(checks)
   end
 
+  desc "Verify that LLM Cost Tracker can capture and persist a synthetic event"
+  task :verify_capture do
+    Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
+    require_relative "../llm_cost_tracker"
+    checks = LlmCostTracker::CaptureVerifier.call
+    puts LlmCostTracker::CaptureVerifier.report(checks)
+    abort("llm_cost_tracker: capture verification failed") unless LlmCostTracker::CaptureVerifier.healthy?(checks)
+  end
+
   desc "Print an LLM cost report from ActiveRecord storage"
   task report: :environment do
     days = (ENV["DAYS"] || LlmCostTracker::Report::DEFAULT_DAYS).to_i
@@ -74,6 +84,17 @@ namespace :llm_cost_tracker do
       puts "  pricing is up to date" if result.up_to_date
       abort("llm_cost_tracker: pricing check failed") unless result.up_to_date
     end
+
+    desc "Explain how a provider/model price is matched. Use PROVIDER=... MODEL=..."
+    task :explain do
+      Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
+      require_relative "../llm_cost_tracker"
+
+      explanation = price_explanation_from_env
+      puts "llm_cost_tracker: #{explanation.message}"
+      print_price_explanation(explanation)
+      abort("llm_cost_tracker: price is incomplete or unknown") unless explanation.complete?
+    end
   end
 end
 # rubocop:enable Metrics/BlockLength
@@ -95,3 +116,31 @@ def price_refresh_output_path
   FileUtils.mkdir_p(File.dirname(path))
   path
 end
+
+def price_explanation_from_env
+  provider = ENV["PROVIDER"].to_s.strip
+  model = ENV["MODEL"].to_s.strip
+  abort("llm_cost_tracker: use PROVIDER=... MODEL=...") if provider.empty? || model.empty?
+
+  LlmCostTracker::Pricing.explain(
+    provider: provider,
+    model: model,
+    pricing_mode: ENV.fetch("PRICING_MODE", nil),
+    input_tokens: ENV.fetch("INPUT_TOKENS", 1).to_i,
+    output_tokens: ENV.fetch("OUTPUT_TOKENS", 1).to_i,
+    cache_read_input_tokens: ENV.fetch("CACHE_READ_INPUT_TOKENS", 0).to_i,
+    cache_write_input_tokens: ENV.fetch("CACHE_WRITE_INPUT_TOKENS", 0).to_i
+  )
+end
+
+def print_price_explanation(explanation)
+  return unless explanation.matched?
+
+  puts "  source: #{explanation.source}"
+  puts "  matched_key: #{explanation.matched_key}"
+  puts "  matched_by: #{explanation.matched_by}"
+  puts "  pricing_mode: #{explanation.pricing_mode || 'standard'}"
+  explanation.effective_prices.each do |key, value|
+    puts "  #{key}: #{value.nil? ? 'missing' : value}"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Sergii Khomenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-27 00:00:00.000000000 Z
+date: 2026-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -222,10 +222,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Tracks token usage, latency, and estimated costs for OpenAI, Anthropic,
-  Google Gemini, OpenRouter, DeepSeek, and OpenAI-compatible APIs. Works through Faraday
-  middleware or explicit track/track_stream helpers, with ActiveRecord storage, tag-based
-  attribution, price sync tasks, and budget guardrails.
+description: Tracks token usage, latency, and estimated costs for RubyLLM, OpenAI,
+  Anthropic, Google Gemini, OpenRouter, DeepSeek, and OpenAI-compatible APIs. Works
+  through Faraday middleware or explicit track/track_stream helpers, with ActiveRecord
+  storage, tag-based attribution, price sync tasks, and budget guardrails.
 email:
 - sergey@mm.st
 executables: []
@@ -255,6 +255,7 @@ files:
 - 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/date_range.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
@@ -282,13 +283,33 @@ files:
 - app/views/llm_cost_tracker/tags/index.html.erb
 - app/views/llm_cost_tracker/tags/show.html.erb
 - config/routes.rb
+- docs/architecture.md
+- docs/budgets.md
+- docs/configuration.md
+- docs/cookbook.md
+- docs/dashboard-overview.png
+- docs/dashboard.md
+- docs/extending.md
+- docs/operations.md
+- docs/pricing.md
+- docs/querying.md
+- docs/streaming.md
+- docs/technical/README.md
+- docs/technical/data-flow.md
+- docs/technical/extension-points.md
+- docs/technical/module-map.md
+- docs/technical/operational-notes.md
+- docs/upgrading.md
 - lib/llm_cost_tracker.rb
 - lib/llm_cost_tracker/assets.rb
 - lib/llm_cost_tracker/budget.rb
+- lib/llm_cost_tracker/capture_verifier.rb
 - lib/llm_cost_tracker/configuration.rb
 - lib/llm_cost_tracker/configuration/instrumentation.rb
+- lib/llm_cost_tracker/configuration/storage_backend.rb
 - lib/llm_cost_tracker/cost.rb
 - lib/llm_cost_tracker/doctor.rb
+- lib/llm_cost_tracker/doctor/capture_check.rb
 - lib/llm_cost_tracker/engine.rb
 - lib/llm_cost_tracker/engine_compatibility.rb
 - lib/llm_cost_tracker/errors.rb
@@ -317,7 +338,10 @@ files:
 - lib/llm_cost_tracker/integrations/object_reader.rb
 - lib/llm_cost_tracker/integrations/openai.rb
 - lib/llm_cost_tracker/integrations/registry.rb
+- lib/llm_cost_tracker/integrations/ruby_llm.rb
+- lib/llm_cost_tracker/integrations/stream_tracker.rb
 - lib/llm_cost_tracker/llm_api_call.rb
+- lib/llm_cost_tracker/llm_api_call_metrics.rb
 - lib/llm_cost_tracker/logging.rb
 - lib/llm_cost_tracker/middleware/faraday.rb
 - lib/llm_cost_tracker/parameter_hash.rb
@@ -341,20 +365,30 @@ files:
 - lib/llm_cost_tracker/price_sync/registry_writer.rb
 - lib/llm_cost_tracker/prices.json
 - lib/llm_cost_tracker/pricing.rb
+- lib/llm_cost_tracker/pricing/effective_prices.rb
+- lib/llm_cost_tracker/pricing/explainer.rb
+- lib/llm_cost_tracker/pricing/lookup.rb
 - lib/llm_cost_tracker/railtie.rb
 - lib/llm_cost_tracker/report.rb
 - lib/llm_cost_tracker/report_data.rb
 - lib/llm_cost_tracker/report_formatter.rb
 - lib/llm_cost_tracker/request_url.rb
 - lib/llm_cost_tracker/retention.rb
+- lib/llm_cost_tracker/storage/active_record_backend.rb
 - lib/llm_cost_tracker/storage/active_record_rollups.rb
 - lib/llm_cost_tracker/storage/active_record_store.rb
+- lib/llm_cost_tracker/storage/custom_backend.rb
 - lib/llm_cost_tracker/storage/dispatcher.rb
+- lib/llm_cost_tracker/storage/log_backend.rb
+- lib/llm_cost_tracker/storage/registry.rb
+- lib/llm_cost_tracker/stream_capture.rb
 - lib/llm_cost_tracker/stream_collector.rb
 - lib/llm_cost_tracker/tag_accessors.rb
 - lib/llm_cost_tracker/tag_context.rb
 - lib/llm_cost_tracker/tag_key.rb
 - lib/llm_cost_tracker/tag_query.rb
+- lib/llm_cost_tracker/tag_sanitizer.rb
+- lib/llm_cost_tracker/tag_sql.rb
 - lib/llm_cost_tracker/tags_column.rb
 - lib/llm_cost_tracker/tracker.rb
 - lib/llm_cost_tracker/unknown_pricing.rb