llm_cost_tracker 0.5.0 → 0.5.2

data/app/controllers/llm_cost_tracker/calls_controller.rb

@@ -84,7 +84,8 @@ module LlmCostTracker
       return value if value.nil?
 
       string = value.to_s
-      CSV_FORMULA_PREFIXES.include?(string[0]) ? "'#{string}" : string
+      stripped = string.lstrip
+      CSV_FORMULA_PREFIXES.include?(stripped[0]) ? "'#{string}" : string
     end
   end
 end

data/app/controllers/llm_cost_tracker/dashboard_controller.rb

@@ -3,7 +3,9 @@
 module LlmCostTracker
   class DashboardController < ApplicationController
     def index
-      @from_date, @to_date = overview_range
+      range = Dashboard::DateRange.call(params: params)
+      @from_date = range.from
+      @to_date = range.to
       prev_from, prev_to = previous_range
       filter_params = LlmCostTracker::ParameterHash.to_hash(params)
       scope = Dashboard::Filter.call(
@@ -23,25 +25,11 @@ module LlmCostTracker
 
     private
 
-    def overview_range
-      to_date = parsed_date(params[:to]) || Date.current
-      from_date = parsed_date(params[:from]) || (to_date - 29)
-      [from_date, to_date]
-    end
-
     def previous_range
       span_days = (@to_date - @from_date).to_i + 1
       prev_to = @from_date - 1
       prev_from = prev_to - (span_days - 1)
       [prev_from, prev_to]
     end
-
-    def parsed_date(value)
-      return nil if value.to_s.strip.empty?
-
-      Date.iso8601(value.to_s)
-    rescue ArgumentError
-      nil
-    end
   end
 end

data/app/controllers/llm_cost_tracker/tags_controller.rb

@@ -8,12 +8,13 @@ module LlmCostTracker
 
     def show
       @tag_key = params[:key]
-      @rows = Dashboard::TagBreakdown.call(scope: Dashboard::Filter.call(params: params), key: @tag_key)
-      @total_calls = @rows.sum(&:calls)
-
-      tagged_rows = @rows.reject { |r| r.value == "(untagged)" }
-      @tagged_calls = tagged_rows.sum(&:calls)
-      @distinct_values = tagged_rows.size
+      breakdown = Dashboard::TagBreakdown.call(scope: Dashboard::Filter.call(params: params), key: @tag_key)
+      @rows = breakdown.rows
+      @total_calls = breakdown.total_calls
+      @tagged_calls = breakdown.tagged_calls
+      @distinct_values = breakdown.distinct_values
+      @tag_value_limit = breakdown.limit
+      @tag_values_limited = breakdown.limited?
     end
   end
 end

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -4,6 +4,9 @@ require "json"
 
 module LlmCostTracker
   module ApplicationHelper
+    TAG_VALUE_SUMMARY_BYTES = 80
+    TAG_TOOLTIP_BYTES = 512
+
     include DashboardFilterHelper
     include DashboardFilterOptionsHelper
     include DashboardQueryHelper
@@ -116,6 +119,10 @@ module LlmCostTracker
       visible
     end
 
+    def tag_chips_title(tags)
+      truncate_text(safe_json(tags), TAG_TOOLTIP_BYTES)
+    end
+
     def budget_fill_modifier(percent)
       percent = percent.to_f
       return "lct-budget-fill--over" if percent >= 100.0
@@ -143,12 +150,20 @@ module LlmCostTracker
     end
 
     def tag_value_summary(value)
-      case value
-      when Hash, Array
-        JSON.generate(value)
-      else
-        value.to_s
-      end
+      string = case value
+               when Hash, Array
+                 JSON.generate(value)
+               else
+                 value.to_s
+               end
+
+      truncate_text(string, TAG_VALUE_SUMMARY_BYTES)
+    end
+
+    def truncate_text(string, limit)
+      return string if string.bytesize <= limit
+
+      "#{string.byteslice(0, limit).to_s.encode('UTF-8', invalid: :replace, undef: :replace)}..."
     end
   end
 end

data/app/helpers/llm_cost_tracker/dashboard_filter_options_helper.rb

@@ -2,6 +2,8 @@
 
 module LlmCostTracker
   module DashboardFilterOptionsHelper
+    MAX_FILTER_OPTIONS = 100
+
     def provider_filter_options(filter_params: params)
       filter_options_for(:provider, filter_params: filter_params)
     end
@@ -19,7 +21,7 @@ module LlmCostTracker
       )
       values = LlmCostTracker::Dashboard::Filter.call(params: scope_params)
                                                 .where.not(column => [nil, ""])
-                                                .distinct.order(column).pluck(column)
+                                                .distinct.order(column).limit(MAX_FILTER_OPTIONS).pluck(column)
       current = source[column.to_s].presence || source[column].presence
       values.unshift(current) if current && !values.include?(current)
       values

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    class DateRange
+      DEFAULT_DAYS = 30
+      MAX_DAYS = 366
+
+      attr_reader :from, :to
+
+      def self.call(params:, today: Date.current)
+        new(params: params, today: today)
+      end
+
+      def self.parse(params, key)
+        value = LlmCostTracker::ParameterHash.with_indifferent_access(params)[key].to_s.strip
+        return nil if value.empty?
+
+        Date.iso8601(value)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.validate!(from:, to:)
+        return if from.nil? && to.nil?
+
+        raise InvalidFilterError, "from and to dates must be provided together" if from.nil? || to.nil?
+        raise InvalidFilterError, "from date must be on or before to date" if from > to
+        return if ((to - from).to_i + 1) <= MAX_DAYS
+
+        raise InvalidFilterError, "date range cannot exceed #{MAX_DAYS} days"
+      end
+
+      def initialize(params:, today:)
+        @to = self.class.parse(params, :to) || today
+        @from = self.class.parse(params, :from) || (@to - (DEFAULT_DAYS - 1))
+        self.class.validate!(from: @from, to: @to)
+        freeze
+      end
+    end
+  end
+end

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

@@ -31,9 +31,12 @@ module LlmCostTracker
       attr_reader :scope, :params
 
       def apply_date_filters(relation)
-        from = parse_date(:from)&.beginning_of_day
-        to = parse_date(:to)&.end_of_day
+        from_date = parse_date(:from)
+        to_date = parse_date(:to)
+        Dashboard::DateRange.validate!(from: from_date, to: to_date)
 
+        from = from_date&.beginning_of_day
+        to = to_date&.end_of_day
         relation = relation.where(tracked_at: from..) if from
         relation = relation.where(tracked_at: ..to) if to
         relation
@@ -89,12 +92,7 @@ module LlmCostTracker
       end
 
       def parse_date(key)
-        value = normalized_string(params[key])
-        return nil if value.nil?
-
-        Date.iso8601(value)
-      rescue ArgumentError
-        nil
+        Dashboard::DateRange.parse(params, key)
       end
 
       def normalized_string(value)

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

@@ -65,11 +65,12 @@ module LlmCostTracker
 
         scope
           .where(tracked_at: window)
-          .pluck(:provider, :model, :tracked_at, :total_cost)
-          .each do |provider, model, tracked_at, total_cost|
-            next if total_cost.nil?
-
-            grouped[[provider, model]][tracked_at.to_date] += total_cost.to_f
+          .where.not(total_cost: nil)
+          .group(:provider, :model)
+          .group_by_period(:day)
+          .sum(:total_cost)
+          .each do |(provider, model, day), total_cost|
+            grouped[[provider, model]][Date.iso8601(day.to_s)] += total_cost.to_f
           end
 
         grouped

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

@@ -9,28 +9,54 @@ module LlmCostTracker
       :average_cost_per_call
     )
 
+    TagBreakdownResult = Data.define(
+      :rows,
+      :total_calls,
+      :tagged_calls,
+      :distinct_values,
+      :limit
+    ) do
+      def limited? = distinct_values > rows.size
+    end
+
     class TagBreakdown
+      DEFAULT_LIMIT = 100
+
       class << self
-        def call(key:, scope: LlmCostTracker::LlmApiCall.all)
-          new(scope: scope, key: key).rows
+        def call(key:, scope: LlmCostTracker::LlmApiCall.all, limit: DEFAULT_LIMIT)
+          new(scope: scope, key: key, limit: limit).result
         end
       end
 
-      def initialize(scope:, key:)
+      def initialize(scope:, key:, limit:)
         @scope = scope
         @key = LlmCostTracker::TagKey.validate!(key, error_class: LlmCostTracker::InvalidFilterError)
+        @limit = normalized_limit(limit)
+        @connection = LlmCostTracker::LlmApiCall.connection
       end
 
-      def rows
-        costs = scope.cost_by_tag(key)
-        counts = counts_by_tag
+      def result
+        counts = summary_counts
 
-        costs.map do |value, total_cost|
-          calls = counts[value].to_i
-          total_cost = total_cost.to_f
+        TagBreakdownResult.new(
+          rows: rows,
+          total_calls: counts.fetch(:total_calls),
+          tagged_calls: counts.fetch(:tagged_calls),
+          distinct_values: counts.fetch(:distinct_values),
+          limit: limit
+        )
+      end
 
+      private
+
+      attr_reader :scope, :key, :limit, :connection
+
+      def rows
+        connection.select_all(rows_sql).map do |row|
+          calls = row["calls_count"].to_i
+          total_cost = row["total_cost_sum"].to_f
           TagBreakdownRow.new(
-            value: value,
+            value: LlmCostTracker::LlmApiCall.tag_value_label(row["tag_value"]),
             calls: calls,
             total_cost: total_cost,
             average_cost_per_call: calls.positive? ? total_cost / calls : 0.0
@@ -38,18 +64,48 @@ module LlmCostTracker
         end
       end
 
-      private
+      def summary_counts
+        row = connection.select_one(summary_sql) || {}
+        {
+          total_calls: row["total_calls"].to_i,
+          tagged_calls: row["tagged_calls"].to_i,
+          distinct_values: row["distinct_values"].to_i
+        }
+      end
 
-      attr_reader :scope, :key
+      def rows_sql
+        <<~SQL.squish
+          SELECT #{tag_expression} AS tag_value,
+                 COUNT(*) AS calls_count,
+                 COALESCE(SUM(sub.total_cost), 0) AS total_cost_sum
+          FROM (#{scope.to_sql}) AS sub
+          WHERE #{tag_present_predicate}
+          GROUP BY #{tag_expression}
+          ORDER BY total_cost_sum DESC, calls_count DESC, tag_value ASC
+          LIMIT #{limit}
+        SQL
+      end
 
-      def counts_by_tag
-        scope.group_by_tag(key).count.each_with_object(Hash.new(0)) do |(raw, count), hash|
-          hash[label(raw)] += count.to_i
-        end
+      def summary_sql
+        <<~SQL.squish
+          SELECT COUNT(*) AS total_calls,
+                 COALESCE(SUM(CASE WHEN #{tag_present_predicate} THEN 1 ELSE 0 END), 0) AS tagged_calls,
+                 COUNT(DISTINCT CASE WHEN #{tag_present_predicate} THEN #{tag_expression} END) AS distinct_values
+          FROM (#{scope.to_sql}) AS sub
+        SQL
+      end
+
+      def tag_present_predicate
+        "#{tag_expression} IS NOT NULL AND #{tag_expression} != ''"
+      end
+
+      def tag_expression
+        @tag_expression ||= LlmCostTracker::LlmApiCall.tag_value_expression(key, table_name: "sub")
       end
 
-      def label(value)
-        value.nil? || value == "" ? "(untagged)" : value.to_s
+      def normalized_limit(value)
+        value = value.to_i
+        value.positive? ? [value, DEFAULT_LIMIT].min : DEFAULT_LIMIT
       end
     end
   end

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

@@ -5,15 +5,18 @@ module LlmCostTracker
     TagKeyRow = Data.define(:key, :calls_count, :distinct_values)
 
     class TagKeyExplorer
+      DEFAULT_LIMIT = 100
+
       class << self
-        def call(scope: LlmCostTracker::LlmApiCall.all)
-          new(scope: scope).rows
+        def call(scope: LlmCostTracker::LlmApiCall.all, limit: DEFAULT_LIMIT)
+          new(scope: scope, limit: limit).rows
         end
       end
 
-      def initialize(scope:)
+      def initialize(scope:, limit:)
         @scope = scope
         @connection = LlmCostTracker::LlmApiCall.connection
+        @limit = normalized_limit(limit)
       end
 
       def rows
@@ -32,7 +35,7 @@ module LlmCostTracker
 
       private
 
-      attr_reader :scope, :connection
+      attr_reader :scope, :connection, :limit
 
       def subquery
         scope.to_sql
@@ -62,6 +65,7 @@ module LlmCostTracker
             AND sub.tags != ''
           GROUP BY jt.key
           ORDER BY calls_count DESC
+          LIMIT #{limit}
         SQL
       end
 
@@ -76,6 +80,7 @@ module LlmCostTracker
             AND sub.tags::jsonb <> '{}'::jsonb
           GROUP BY key
           ORDER BY calls_count DESC
+          LIMIT #{limit}
         SQL
       end
 
@@ -91,8 +96,14 @@ module LlmCostTracker
             AND sub.tags != ''
           GROUP BY je.key
           ORDER BY calls_count DESC
+          LIMIT #{limit}
         SQL
       end
+
+      def normalized_limit(value)
+        value = value.to_i
+        value.positive? ? [value, DEFAULT_LIMIT].min : DEFAULT_LIMIT
+      end
     end
   end
 end

data/app/views/llm_cost_tracker/shared/_tag_chips.html.erb

@@ -2,7 +2,7 @@
 <% if entries.empty? %>
   <span class="lct-tag-empty">(untagged)</span>
 <% else %>
-  <span class="lct-tag-chips" title="<%= safe_json(tags) %>">
+  <span class="lct-tag-chips" title="<%= tag_chips_title(tags) %>">
     <% entries.each do |entry| %>
       <% if entry[:more] %>
         <span class="lct-tag-chip lct-tag-chip-more">+<%= entry[:more] %></span>

data/app/views/llm_cost_tracker/tags/show.html.erb

@@ -50,6 +50,10 @@
     <span><strong><%= percent(coverage_percent(@tagged_calls, @total_calls)) %></strong> coverage</span>
     <span><strong><%= number(@distinct_values) %></strong> distinct values</span>
   </p>
+
+  <% if @tag_values_limited %>
+    <p class="lct-toolbar-note">Showing top <%= number(@tag_value_limit) %> values by spend.</p>
+  <% end %>
 </section>
 
 <% if @rows.empty? %>

data/lib/llm_cost_tracker/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "tag_key"
 require_relative "value_helpers"
 require_relative "configuration/instrumentation"
 
@@ -8,31 +9,21 @@ module LlmCostTracker
   class Configuration
     include ConfigurationInstrumentation
 
-    OPENAI_COMPATIBLE_PROVIDERS = {
-      "openrouter.ai" => "openrouter",
-      "api.deepseek.com" => "deepseek"
-    }.freeze
+    OPENAI_COMPATIBLE_PROVIDERS = { "openrouter.ai" => "openrouter", "api.deepseek.com" => "deepseek" }.freeze
 
     BUDGET_EXCEEDED_BEHAVIORS = %i[notify raise block_requests].freeze
     STORAGE_ERROR_BEHAVIORS = %i[ignore warn raise].freeze
     STORAGE_BACKENDS = %i[log active_record custom].freeze
     UNKNOWN_PRICING_BEHAVIORS = %i[ignore warn raise].freeze
-    SHARED_SCALAR_ATTRIBUTES = %i[
-      enabled
-      custom_storage
-      on_budget_exceeded
-      monthly_budget
-      daily_budget
-      per_call_budget
-      log_level
-      prices_file
-    ].freeze
+    SHARED_SCALAR_ATTRIBUTES = %i[enabled custom_storage on_budget_exceeded monthly_budget daily_budget per_call_budget
+                                  log_level prices_file max_tag_count max_tag_value_bytesize].freeze
     SHARED_ENUM_ATTRIBUTES = {
       storage_backend: [STORAGE_BACKENDS, :log],
       budget_exceeded_behavior: [BUDGET_EXCEEDED_BEHAVIORS, :notify],
       storage_error_behavior: [STORAGE_ERROR_BEHAVIORS, :warn],
       unknown_pricing_behavior: [UNKNOWN_PRICING_BEHAVIORS, :warn]
     }.freeze
+    DEFAULT_REDACTED_TAG_KEYS = %w[api_key access_token authorization credential password refresh_token secret].freeze
 
     attr_reader(
       *SHARED_SCALAR_ATTRIBUTES,
@@ -41,6 +32,7 @@ module LlmCostTracker
       :pricing_overrides,
       :instrumented_integrations,
       :report_tag_breakdowns,
+      :redacted_tag_keys,
       :storage_backend,
       :storage_error_behavior,
       :unknown_pricing_behavior,
@@ -61,9 +53,12 @@ module LlmCostTracker
       self.unknown_pricing_behavior = :warn
       @log_level          = :info
       @prices_file        = nil
-      @pricing_overrides  = {}
+      @max_tag_count      = 50
+      @max_tag_value_bytesize = 1024
+      @pricing_overrides = {}
       @instrumented_integrations = []
       @report_tag_breakdowns = []
+      @redacted_tag_keys = DEFAULT_REDACTED_TAG_KEYS.dup
       self.openai_compatible_providers = OPENAI_COMPATIBLE_PROVIDERS
       @finalized = false
     end
@@ -85,7 +80,12 @@ module LlmCostTracker
 
     def report_tag_breakdowns=(value)
       ensure_shared_configuration_mutable!
-      @report_tag_breakdowns = value
+      @report_tag_breakdowns = normalize_report_tag_breakdowns(value)
+    end
+
+    def redacted_tag_keys=(value)
+      ensure_shared_configuration_mutable!
+      @redacted_tag_keys = Array(value).map(&:to_s)
     end
 
     SHARED_SCALAR_ATTRIBUTES.each do |name|
@@ -107,6 +107,7 @@ module LlmCostTracker
       @pricing_overrides = ValueHelpers.deep_freeze(@pricing_overrides || {})
       @instrumented_integrations = ValueHelpers.deep_freeze(@instrumented_integrations || [])
       @report_tag_breakdowns = ValueHelpers.deep_freeze(Array(@report_tag_breakdowns))
+      @redacted_tag_keys = ValueHelpers.deep_freeze(Array(@redacted_tag_keys))
       @openai_compatible_providers = ValueHelpers.deep_freeze(@openai_compatible_providers || {})
       @finalized = true
       self
@@ -123,6 +124,7 @@ module LlmCostTracker
         ValueHelpers.deep_dup(@instrumented_integrations || [])
       )
       copy.instance_variable_set(:@report_tag_breakdowns, ValueHelpers.deep_dup(@report_tag_breakdowns || []))
+      copy.instance_variable_set(:@redacted_tag_keys, ValueHelpers.deep_dup(@redacted_tag_keys || []))
       copy.instance_variable_set(
         :@openai_compatible_providers,
         ValueHelpers.deep_dup(@openai_compatible_providers || {})
@@ -149,6 +151,10 @@ module LlmCostTracker
       end
     end
 
+    def normalize_report_tag_breakdowns(value)
+      Array(value).map { |key| TagKey.validate!(key, error_class: Error) }
+    end
+
     def ensure_shared_configuration_mutable!
       return unless finalized?
 

data/lib/llm_cost_tracker/doctor.rb

@@ -160,7 +160,7 @@ module LlmCostTracker
     def feature_generators(columns) = columns.map { |column| FEATURE_COLUMNS.fetch(column) }.uniq
 
     def builtin_prices_updated_at
-      LlmCostTracker::Pricing.metadata.fetch("updated_at", "unknown")
+      LlmCostTracker::PriceRegistry.metadata.fetch("updated_at", "unknown")
     end
   end
 end

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

@@ -39,6 +39,7 @@ module LlmCostTracker
 
         add_engine_require
         route %(mount LlmCostTracker::Engine => "/llm-costs")
+        say "Mount /llm-costs behind your app's admin auth before deploying.", :yellow
       end
 
       private

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/initializer.rb.erb

@@ -11,10 +11,16 @@ LlmCostTracker.configure do |config|
   # Tags are merged into every event. Use a callable for request/job-time context.
   config.default_tags = -> { { environment: Rails.env } }
 
+  # Tag guardrails keep accidental high-cardinality or sensitive values out of the ledger.
+  # config.max_tag_count = 50
+  # config.max_tag_value_bytesize = 1024
+  # config.redacted_tag_keys = %w[api_key access_token authorization credential password refresh_token secret]
+
   # Optional SDK integrations. Provider SDK gems are not installed by LLM Cost Tracker.
-  # Enable only the SDKs your app already uses.
+  # Enabled integrations are checked at boot, so enable only clients your app loads.
   # config.instrument :openai
   # config.instrument :anthropic
+  # config.instrument :ruby_llm
 
   # Budget behavior: :notify calls on_budget_exceeded, :raise raises after recording,
   # :block_requests preflights monthly/daily budgets before supported requests.
@@ -33,7 +39,7 @@ LlmCostTracker.configure do |config|
 <% if options[:prices] -%>
 
   # Local JSON/YAML pricing file generated by --prices. Keep it in source control
-  # and refresh it with bin/rails llm_cost_tracker:prices:sync.
+  # and refresh it with bin/rails llm_cost_tracker:prices:refresh.
   config.prices_file = Rails.root.join("config/llm_cost_tracker_prices.yml")
 <% end -%>
 

data/lib/llm_cost_tracker/integrations/anthropic.rb

@@ -10,10 +10,19 @@ module LlmCostTracker
       class << self
         def integration_name = :anthropic
 
-        def target_patches
+        def minimum_version = "1.36.0"
+
+        def version_constant = "Anthropic::VERSION"
+
+        def patch_targets
           [
-            [constant("Anthropic::Resources::Messages"), MessagesPatch],
-            [constant("Anthropic::Resources::Beta::Messages"), MessagesPatch]
+            patch_target("Anthropic::Resources::Messages", with: MessagesPatch, methods: :create),
+            patch_target(
+              "Anthropic::Resources::Beta::Messages",
+              with: MessagesPatch,
+              methods: :create,
+              optional: true
+            )
           ]
         end