llm_cost_tracker 0.4.0 → 0.5.0

data/app/services/llm_cost_tracker/dashboard/data_quality.rb

@@ -29,84 +29,85 @@ module LlmCostTracker
     class DataQuality
       class << self
         def call(scope: LlmCostTracker::LlmApiCall.all)
-          total = scope.count
+          model = scope.klass
+          aggregates = DataQualityAggregate.call(scope: scope)
+          total = aggregates.fetch(:total_calls).to_i
 
           DataQualityStats.new(
             total_calls: total,
-            unknown_pricing_count: scope.unknown_pricing.count,
-            untagged_calls_count: total - scope.with_json_tags.count,
-            **latency_stats(scope),
-            **stream_stats(scope),
-            **provider_response_id_stats(scope),
-            **usage_stats(scope),
+            unknown_pricing_count: aggregates.fetch(:unknown_pricing_count).to_i,
+            untagged_calls_count: total - aggregates.fetch(:tagged_calls_count).to_i,
+            **latency_stats(aggregates, model:),
+            **stream_stats(aggregates, model:),
+            **provider_response_id_stats(aggregates, model:),
+            **usage_stats(aggregates, model:),
             unknown_pricing_by_model: unknown_pricing_by_model(scope)
           )
         end
 
         private
 
-        def latency_stats(scope)
-          latency_present = LlmCostTracker::LlmApiCall.latency_column?
+        def latency_stats(aggregates, model:)
+          latency_present = model.latency_column?
 
           {
-            missing_latency_count: latency_present ? scope.where(latency_ms: nil).count : nil,
+            missing_latency_count: latency_present ? aggregates.fetch(:missing_latency_count).to_i : nil,
             latency_column_present: latency_present
           }
         end
 
-        def stream_stats(scope)
-          stream_present = LlmCostTracker::LlmApiCall.stream_column?
+        def stream_stats(aggregates, model:)
+          stream_present = model.stream_column?
+          usage_source_present = model.usage_source_column?
+          streaming_missing_usage_count = nil
+          if stream_present && usage_source_present
+            streaming_missing_usage_count = aggregates.fetch(:streaming_missing_usage_count).to_i
+          end
 
           {
-            streaming_count: stream_present ? scope.streaming.count : nil,
-            streaming_missing_usage_count: streaming_missing_usage_count(scope, stream_present),
+            streaming_count: stream_present ? aggregates.fetch(:streaming_count).to_i : nil,
+            streaming_missing_usage_count: streaming_missing_usage_count,
             stream_column_present: stream_present
           }
         end
 
-        def provider_response_id_stats(scope)
-          column_present = LlmCostTracker::LlmApiCall.provider_response_id_column?
+        def provider_response_id_stats(aggregates, model:)
+          column_present = model.provider_response_id_column?
+          missing_provider_response_id_count = nil
+          if column_present
+            missing_provider_response_id_count = aggregates.fetch(:missing_provider_response_id_count).to_i
+          end
 
           {
-            missing_provider_response_id_count: column_present ? scope.missing_provider_response_id.count : nil,
+            missing_provider_response_id_count: missing_provider_response_id_count,
             provider_response_id_column_present: column_present
           }
         end
 
-        def usage_stats(scope)
-          usage_breakdown_present = LlmCostTracker::LlmApiCall.usage_breakdown_columns?
-          usage_breakdown_cost_present = LlmCostTracker::LlmApiCall.usage_breakdown_cost_columns?
-          sums = sum_columns(scope, usage_sum_columns(usage_breakdown_present, usage_breakdown_cost_present))
+        def usage_stats(aggregates, model:)
+          usage_breakdown_present = model.usage_breakdown_columns?
+          usage_breakdown_cost_present = model.usage_breakdown_cost_columns?
+          cache_read_input_cost = nil
+          cache_write_input_cost = nil
+          if usage_breakdown_cost_present
+            cache_read_input_cost = decimal_sum(aggregates.fetch(:cache_read_input_cost))
+            cache_write_input_cost = decimal_sum(aggregates.fetch(:cache_write_input_cost))
+          end
 
           {
             usage_breakdown_column_present: usage_breakdown_present,
-            input_tokens: sums[:input_tokens].to_i,
-            cache_read_input_tokens: usage_breakdown_present ? sums[:cache_read_input_tokens].to_i : nil,
-            cache_write_input_tokens: usage_breakdown_present ? sums[:cache_write_input_tokens].to_i : nil,
-            output_tokens: sums[:output_tokens].to_i,
-            hidden_output_tokens: usage_breakdown_present ? sums[:hidden_output_tokens].to_i : nil,
-            input_cost: decimal_sum(sums[:input_cost]),
-            cache_read_input_cost: usage_breakdown_cost_present ? decimal_sum(sums[:cache_read_input_cost]) : nil,
-            cache_write_input_cost: usage_breakdown_cost_present ? decimal_sum(sums[:cache_write_input_cost]) : nil,
-            output_cost: decimal_sum(sums[:output_cost])
+            input_tokens: aggregates.fetch(:input_tokens).to_i,
+            cache_read_input_tokens: usage_breakdown_present ? aggregates.fetch(:cache_read_input_tokens).to_i : nil,
+            cache_write_input_tokens: usage_breakdown_present ? aggregates.fetch(:cache_write_input_tokens).to_i : nil,
+            output_tokens: aggregates.fetch(:output_tokens).to_i,
+            hidden_output_tokens: usage_breakdown_present ? aggregates.fetch(:hidden_output_tokens).to_i : nil,
+            input_cost: decimal_sum(aggregates.fetch(:input_cost)),
+            cache_read_input_cost: cache_read_input_cost,
+            cache_write_input_cost: cache_write_input_cost,
+            output_cost: decimal_sum(aggregates.fetch(:output_cost))
           }
         end
 
-        def usage_sum_columns(usage_breakdown_present, usage_breakdown_cost_present)
-          columns = %i[input_tokens output_tokens input_cost output_cost]
-          if usage_breakdown_present
-            columns += %i[cache_read_input_tokens cache_write_input_tokens hidden_output_tokens]
-          end
-          columns += %i[cache_read_input_cost cache_write_input_cost] if usage_breakdown_cost_present
-          columns
-        end
-
-        def streaming_missing_usage_count(scope, stream_present)
-          return unless stream_present && LlmCostTracker::LlmApiCall.usage_source_column?
-
-          scope.streaming_missing_usage.count
-        end
-
         def unknown_pricing_by_model(scope)
           scope.unknown_pricing
                .group(:model)
@@ -116,16 +117,6 @@ module LlmCostTracker
                .to_h
         end
 
-        def sum_columns(scope, columns)
-          values = scope.unscope(:order).pick(*columns.map { |column| sum_expression(scope, column) })
-
-          columns.zip(values).to_h
-        end
-
-        def sum_expression(scope, column)
-          Arel.sql("COALESCE(SUM(#{scope.connection.quote_column_name(column)}), 0)")
-        end
-
         def decimal_sum(value)
           value.to_f.round(8)
         end

data/app/services/llm_cost_tracker/dashboard/data_quality_aggregate.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    class DataQualityAggregate
+      class << self
+        def call(scope:)
+          model = scope.klass
+          expressions = aggregate_expressions(scope, model:)
+          values = Array(scope.unscope(:order).pick(*expressions.values))
+
+          expressions.keys.zip(values).to_h
+        end
+
+        private
+
+        def aggregate_expressions(scope, model:)
+          usage_breakdown_present = model.usage_breakdown_columns?
+          usage_breakdown_cost_present = model.usage_breakdown_cost_columns?
+
+          expressions = {
+            total_calls: Arel.sql("COUNT(*)"),
+            unknown_pricing_count: conditional_count_expression("total_cost IS NULL"),
+            tagged_calls_count: tagged_calls_expression(model)
+          }
+
+          if model.latency_column?
+            expressions[:missing_latency_count] = conditional_count_expression("latency_ms IS NULL")
+          end
+          expressions[:streaming_count] = conditional_count_expression("stream") if model.stream_column?
+          if model.stream_column? && model.usage_source_column?
+            expressions[:streaming_missing_usage_count] =
+              conditional_count_expression("stream AND (usage_source = 'unknown' OR usage_source IS NULL)")
+          end
+          if model.provider_response_id_column?
+            expressions[:missing_provider_response_id_count] =
+              conditional_count_expression("provider_response_id IS NULL OR provider_response_id = ''")
+          end
+
+          usage_sum_columns(usage_breakdown_present, usage_breakdown_cost_present).each do |column|
+            expressions[column] = sum_expression(scope, column)
+          end
+
+          expressions
+        end
+
+        def usage_sum_columns(usage_breakdown_present, usage_breakdown_cost_present)
+          columns = %i[input_tokens output_tokens input_cost output_cost]
+          if usage_breakdown_present
+            columns += %i[cache_read_input_tokens cache_write_input_tokens hidden_output_tokens]
+          end
+          columns += %i[cache_read_input_cost cache_write_input_cost] if usage_breakdown_cost_present
+          columns
+        end
+
+        def conditional_count_expression(predicate)
+          Arel.sql("COALESCE(SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END), 0)")
+        end
+
+        def tagged_calls_expression(model)
+          table = model.quoted_table_name
+          column = "#{table}.#{model.connection.quote_column_name('tags')}"
+
+          Arel.sql(case
+                   when model.tags_jsonb_column?
+                     "COALESCE(SUM(CASE WHEN #{column} <> '{}'::jsonb THEN 1 ELSE 0 END), 0)"
+                   when model.tags_mysql_json_column?
+                     "COALESCE(SUM(CASE WHEN JSON_LENGTH(#{column}) > 0 THEN 1 ELSE 0 END), 0)"
+                   else
+                     "COALESCE(SUM(CASE WHEN #{column} IS NOT NULL AND #{column} <> '' " \
+                     "AND #{column} <> '{}' THEN 1 ELSE 0 END), 0)"
+                   end)
+        end
+
+        def sum_expression(scope, column)
+          Arel.sql("COALESCE(SUM(#{scope.connection.quote_column_name(column)}), 0)")
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/budget.rb

@@ -10,8 +10,16 @@ module LlmCostTracker
         return unless config.budget_exceeded_behavior == :block_requests
         return unless config.active_record?
 
-        enforce_period_budget(:monthly, config.monthly_budget)
-        enforce_period_budget(:daily, config.daily_budget)
+        budgets = enforce_period_budgets(config)
+        return if budgets.empty?
+
+        totals = active_record_totals(budgets.keys, time: Time.now.utc)
+
+        budgets.each do |period, budget|
+          total = totals.fetch(period)
+
+          handle_exceeded(budget_type: period, total: total, budget: budget) if total >= budget
+        end
       end
 
       def check!(event)
@@ -19,21 +27,18 @@ module LlmCostTracker
         return unless event.cost
 
         check_per_call_budget(event, config)
-        check_period_budget(event, config, :daily, config.daily_budget)
-        check_period_budget(event, config, :monthly, config.monthly_budget)
-      end
+        budgets = check_period_budgets(config)
+        totals = totals_for_check(event, config, budgets)
 
-      private
-
-      def enforce_period_budget(period, budget)
-        return unless budget
+        budgets.each do |period, budget|
+          total = totals.fetch(period)
 
-        total = active_record_total(period, time: Time.now.utc)
-        return unless total >= budget
-
-        handle_exceeded(budget_type: period, total: total, budget: budget)
+          handle_exceeded(budget_type: period, total: total, budget: budget, last_event: event) if total >= budget
+        end
       end
 
+      private
+
       def check_per_call_budget(event, config)
         budget = config.per_call_budget
         return unless budget
@@ -44,40 +49,32 @@ module LlmCostTracker
         handle_exceeded(budget_type: :per_call, total: call_cost, budget: budget, last_event: event)
       end
 
-      def check_period_budget(event, config, period, budget)
-        return unless budget
-
-        total = if config.active_record?
-                  active_record_total(period, time: event.tracked_at)
-                else
-                  event.cost.total_cost
-                end
-        return unless total >= budget
-
-        handle_exceeded(budget_type: period, total: total, budget: budget, last_event: event)
+      def enforce_period_budgets(config)
+        {
+          monthly: config.monthly_budget,
+          daily: config.daily_budget
+        }.compact
       end
 
-      def active_record_total(period, time:)
-        case period
-        when :monthly then active_record_monthly_total(time: time)
-        when :daily   then active_record_daily_total(time: time)
-        end
+      def check_period_budgets(config)
+        {
+          daily: config.daily_budget,
+          monthly: config.monthly_budget
+        }.compact
       end
 
-      def active_record_monthly_total(time: Time.now.utc)
-        require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
-        require_relative "storage/active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
+      def totals_for_check(event, config, budgets)
+        return {} if budgets.empty?
+        return active_record_totals(budgets.keys, time: event.tracked_at) if config.active_record?
 
-        LlmCostTracker::Storage::ActiveRecordStore.monthly_total(time: time)
-      rescue LoadError => e
-        raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
+        budgets.to_h { |period, _budget| [period, event.cost.total_cost] }
       end
 
-      def active_record_daily_total(time: Time.now.utc)
+      def active_record_totals(periods, time:)
         require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
         require_relative "storage/active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
 
-        LlmCostTracker::Storage::ActiveRecordStore.daily_total(time: time)
+        LlmCostTracker::Storage::ActiveRecordStore.period_totals(periods, time: time)
       rescue LoadError => e
         raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
       end

data/lib/llm_cost_tracker/configuration/instrumentation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module ConfigurationInstrumentation
+    def instrument(*names)
+      ensure_shared_configuration_mutable!
+      @instrumented_integrations = (@instrumented_integrations + normalize_instrumentation_names(names)).uniq
+    end
+
+    def instrumented?(name)
+      @instrumented_integrations.include?(name.to_sym)
+    end
+
+    private
+
+    def normalize_instrumentation_names(names)
+      names.flatten.flat_map do |name|
+        key = name.to_sym
+        next available_instrumentation_names if key == :all
+
+        validate_instrumentation_name!(key)
+        key
+      end
+    end
+
+    def validate_instrumentation_name!(name)
+      return if available_instrumentation_names.include?(name)
+
+      raise Error, "Unknown integration: #{name.inspect}. " \
+                   "Use one of: #{available_instrumentation_names.join(', ')}"
+    end
+
+    def available_instrumentation_names
+      Integrations::Registry::INTEGRATIONS.keys
+    end
+  end
+end

data/lib/llm_cost_tracker/configuration.rb

@@ -2,9 +2,12 @@
 
 require_relative "errors"
 require_relative "value_helpers"
+require_relative "configuration/instrumentation"
 
 module LlmCostTracker
   class Configuration
+    include ConfigurationInstrumentation
+
     OPENAI_COMPATIBLE_PROVIDERS = {
       "openrouter.ai" => "openrouter",
       "api.deepseek.com" => "deepseek"
@@ -36,6 +39,7 @@ module LlmCostTracker
       :budget_exceeded_behavior,
       :default_tags,
       :pricing_overrides,
+      :instrumented_integrations,
       :report_tag_breakdowns,
       :storage_backend,
       :storage_error_behavior,
@@ -58,6 +62,7 @@ module LlmCostTracker
       @log_level          = :info
       @prices_file        = nil
       @pricing_overrides  = {}
+      @instrumented_integrations = []
       @report_tag_breakdowns = []
       self.openai_compatible_providers = OPENAI_COMPATIBLE_PROVIDERS
       @finalized = false
@@ -97,13 +102,10 @@ module LlmCostTracker
       end
     end
 
-    def normalize_openai_compatible_providers!
-      self.openai_compatible_providers = openai_compatible_providers
-    end
-
     def finalize!
       @default_tags = ValueHelpers.deep_freeze(@default_tags || {})
       @pricing_overrides = ValueHelpers.deep_freeze(@pricing_overrides || {})
+      @instrumented_integrations = ValueHelpers.deep_freeze(@instrumented_integrations || [])
       @report_tag_breakdowns = ValueHelpers.deep_freeze(Array(@report_tag_breakdowns))
       @openai_compatible_providers = ValueHelpers.deep_freeze(@openai_compatible_providers || {})
       @finalized = true
@@ -116,6 +118,10 @@ module LlmCostTracker
       copy = dup
       copy.instance_variable_set(:@default_tags, ValueHelpers.deep_dup(@default_tags || {}))
       copy.instance_variable_set(:@pricing_overrides, ValueHelpers.deep_dup(@pricing_overrides || {}))
+      copy.instance_variable_set(
+        :@instrumented_integrations,
+        ValueHelpers.deep_dup(@instrumented_integrations || [])
+      )
       copy.instance_variable_set(:@report_tag_breakdowns, ValueHelpers.deep_dup(@report_tag_breakdowns || []))
       copy.instance_variable_set(
         :@openai_compatible_providers,
@@ -126,7 +132,6 @@ module LlmCostTracker
     end
 
     def active_record? = storage_backend == :active_record
-    def log? = storage_backend == :log
 
     private
 

data/lib/llm_cost_tracker/doctor.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "price_freshness"
+
+module LlmCostTracker
+  class Doctor
+    Check = Data.define(:status, :name, :message)
+    CORE_COLUMNS = %w[provider model input_tokens output_tokens total_tokens total_cost tags tracked_at].freeze
+    FEATURE_COLUMNS = {
+      "latency_ms" => "bin/rails generate llm_cost_tracker:add_latency_ms",
+      "stream" => "bin/rails generate llm_cost_tracker:add_streaming",
+      "usage_source" => "bin/rails generate llm_cost_tracker:add_streaming",
+      "provider_response_id" => "bin/rails generate llm_cost_tracker:add_provider_response_id",
+      "cache_read_input_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
+      "cache_write_input_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
+      "hidden_output_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
+      "pricing_mode" => "bin/rails generate llm_cost_tracker:add_usage_breakdown"
+    }.freeze
+
+    class << self
+      def call = new.checks
+
+      def report(checks = call)
+        (["LLM Cost Tracker doctor"] + checks.map { |check| format_check(check) }).join("\n")
+      end
+
+      def healthy?(checks = call)
+        checks.none? { |check| check.status == :error }
+      end
+
+      private
+
+      def format_check(check)
+        "[#{check.status}] #{check.name}: #{check.message}"
+      end
+    end
+
+    def checks
+      [
+        configuration_check,
+        *integration_checks,
+        active_record_check,
+        table_check,
+        column_check,
+        period_totals_check,
+        prices_check,
+        calls_check
+      ].compact
+    end
+
+    private
+
+    def configuration_check
+      Check.new(:ok, "configuration", "storage_backend=#{LlmCostTracker.configuration.storage_backend.inspect}")
+    end
+
+    def integration_checks
+      LlmCostTracker::Integrations.checks.map do |check|
+        Check.new(check.status, check.name.to_s, check.message)
+      end
+    end
+
+    def active_record_check
+      return Check.new(:ok, "storage", "ActiveRecord storage is disabled") unless active_record_storage?
+      return Check.new(:ok, "active_record", "available") if active_record_available?
+
+      Check.new(:error, "active_record", "unavailable; add ActiveRecord/Rails or change storage_backend")
+    end
+
+    def table_check
+      return unless active_record_storage? && active_record_available?
+      return Check.new(:ok, "llm_api_calls", "table exists") if llm_api_calls_table?
+
+      Check.new(
+        :error,
+        "llm_api_calls",
+        "missing; run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
+      )
+    end
+
+    def column_check
+      return unless active_record_storage? && llm_api_calls_table?
+
+      columns = column_names("llm_api_calls")
+      missing_core = CORE_COLUMNS - columns
+      missing_features = FEATURE_COLUMNS.keys - columns
+      if missing_core.any?
+        return Check.new(:error, "llm_api_calls columns", "missing core columns: #{missing_core.join(', ')}")
+      end
+      if missing_features.any?
+        return Check.new(
+          :warn,
+          "llm_api_calls columns",
+          "missing optional columns; run #{feature_generators(missing_features).join(' && ')}"
+        )
+      end
+
+      Check.new(:ok, "llm_api_calls columns", "current")
+    end
+
+    def period_totals_check
+      return unless active_record_storage? && llm_api_calls_table?
+      if table_exists?("llm_cost_tracker_period_totals")
+        return Check.new(:ok, "period totals", "llm_cost_tracker_period_totals exists")
+      end
+
+      Check.new(:warn, "period totals", "missing; budget preflight falls back to llm_api_calls sums")
+    end
+
+    def prices_check
+      path = LlmCostTracker.configuration.prices_file
+      unless path
+        return Check.new(
+          :warn,
+          "prices",
+          "using bundled prices updated_at=#{builtin_prices_updated_at}; configure prices_file for production"
+        )
+      end
+
+      count = LlmCostTracker::PriceRegistry.file_prices(path).size
+      metadata = LlmCostTracker::PriceRegistry.file_metadata(path)
+      status, freshness = LlmCostTracker::PriceFreshness.call(metadata)
+      Check.new(status, "prices", "loaded #{count} models from #{path}; #{freshness}")
+    rescue LlmCostTracker::Error => e
+      Check.new(:error, "prices", e.message)
+    end
+
+    def calls_check
+      return unless active_record_storage? && llm_api_calls_table?
+
+      count = LlmCostTracker::LlmApiCall.count
+      return Check.new(:warn, "tracked calls", "none recorded yet") if count.zero?
+
+      latest = LlmCostTracker::LlmApiCall.maximum(:tracked_at)&.utc&.iso8601
+      Check.new(:ok, "tracked calls", "#{count} recorded; latest #{latest}")
+    end
+
+    def active_record_storage? = LlmCostTracker.configuration.storage_backend == :active_record
+
+    def active_record_available?
+      require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
+      LlmCostTracker::LlmApiCall.connection
+      true
+    rescue LoadError, StandardError
+      false
+    end
+
+    def llm_api_calls_table?
+      active_record_available? && table_exists?("llm_api_calls")
+    end
+
+    def table_exists?(name)
+      LlmCostTracker::LlmApiCall.connection.data_source_exists?(name)
+    rescue StandardError
+      false
+    end
+
+    def column_names(table) = LlmCostTracker::LlmApiCall.connection.columns(table).map(&:name)
+
+    def feature_generators(columns) = columns.map { |column| FEATURE_COLUMNS.fetch(column) }.uniq
+
+    def builtin_prices_updated_at
+      LlmCostTracker::Pricing.metadata.fetch("updated_at", "unknown")
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/install_generator.rb

@@ -11,6 +11,8 @@ module LlmCostTracker
       source_root File.expand_path("templates", __dir__)
 
       desc "Creates the LlmCostTracker migration and initializer"
+      class_option :dashboard, type: :boolean, default: false
+      class_option :prices, type: :boolean, default: false
 
       def create_migration_file
         migration_template(
@@ -26,11 +28,42 @@ module LlmCostTracker
         )
       end
 
+      def create_prices_file
+        return unless options[:prices]
+
+        invoke "llm_cost_tracker:prices"
+      end
+
+      def mount_engine
+        return unless options[:dashboard]
+
+        add_engine_require
+        route %(mount LlmCostTracker::Engine => "/llm-costs")
+      end
+
       private
 
       def migration_version
         "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end
+
+      def add_engine_require
+        return unless File.exist?("config/application.rb")
+
+        contents = File.read("config/application.rb")
+        return if contents.include?(%(require "llm_cost_tracker/engine"))
+
+        unless contents.include?(%(require "rails/all"\n))
+          prepend_to_file("config/application.rb", %(require "llm_cost_tracker/engine"\n))
+          return
+        end
+
+        inject_into_file(
+          "config/application.rb",
+          %(require "llm_cost_tracker/engine"\n),
+          after: %(require "rails/all"\n)
+        )
+      end
     end
   end
 end