llm_cost_tracker 0.10.0 → 0.12.0

data/app/controllers/llm_cost_tracker/application_controller.rb

@@ -10,6 +10,7 @@ module LlmCostTracker
 
     before_action :set_dashboard_security_headers
     before_action :ensure_current_schema
+    before_action :assign_dashboard_date_range
 
     helper_method :dashboard_csp_nonce
 
@@ -30,6 +31,12 @@ module LlmCostTracker
       render template: "llm_cost_tracker/shared/setup_required"
     end
 
+    def assign_dashboard_date_range
+      range = LlmCostTracker::Dashboard::DateRange.call(params: params)
+      @from_date = range.from
+      @to_date = range.to
+    end
+
     def render_database_error(error)
       @error = error
       render "llm_cost_tracker/errors/database", status: :internal_server_error
@@ -48,8 +55,13 @@ module LlmCostTracker
       nonce = dashboard_csp_nonce
       response.headers["X-Frame-Options"] = "DENY"
       response.headers["Referrer-Policy"] = "same-origin"
-      response.headers["Content-Security-Policy"] =
-        "default-src 'self'; style-src 'self' 'nonce-#{nonce}'; img-src 'self' data:; frame-ancestors 'none'"
+      response.headers["Content-Security-Policy"] = [
+        "default-src 'self'",
+        "script-src 'self' 'nonce-#{nonce}'",
+        "style-src 'self' 'nonce-#{nonce}'",
+        "img-src 'self' data:",
+        "frame-ancestors 'none'"
+      ].join("; ")
     end
 
     def dashboard_csp_nonce

data/app/controllers/llm_cost_tracker/calls_controller.rb

@@ -8,19 +8,25 @@ module LlmCostTracker
     CSV_EXPORT_LIMIT = 10_000
     CSV_EXPORT_BATCH_SIZE = 500
     CSV_FORMULA_PREFIXES = ["=", "+", "-", "@", "\t", "\r"].freeze
-    DEFAULT_ORDER = "tracked_at DESC, id DESC"
+    DEFAULT_TIEBREAKER = { tracked_at: :desc, id: :desc }.freeze
+    SORT_OPTIONS = %w[tracked_at provider model input output cost latency].freeze
+    NULLS_LAST_GUARD = {
+      total_cost: Arel.sql("CASE WHEN total_cost IS NULL THEN 1 ELSE 0 END ASC"),
+      latency_ms: Arel.sql("CASE WHEN latency_ms IS NULL THEN 1 ELSE 0 END ASC")
+    }.freeze
 
     def index
       @sort = params[:sort].to_s
+      @dir = params[:dir].to_s
       scope = Dashboard::Filter.call(params: params)
-      scope = scope.unknown_pricing if @sort == "unknown_pricing"
-      ordered_scope = scope.order(Arel.sql(calls_order(@sort)))
+      scope = scope.unknown_pricing if params[:cost_status].to_s == "incomplete"
+      ordered_scope = scope.order(*calls_order(@sort, @dir))
 
       respond_to do |format|
         format.html do
           @page = Dashboard::Pagination.call(params)
-          @calls_count = scope.count
-          @calls = ordered_scope.includes(:tag_records).limit(@page.limit).offset(@page.offset).to_a
+          @calls_count, @calls_total_cost = scope.pick(Arel.sql("COUNT(*), COALESCE(SUM(total_cost), 0)"))
+          @calls = ordered_scope.includes(:tag_records).limit(@page.per).offset(@page.offset).to_a
         end
         format.csv do
           response.headers["Cache-Control"] = "no-store"
@@ -37,18 +43,19 @@ module LlmCostTracker
 
     private
 
-    def calls_order(sort)
-      case sort
-      when "expensive"
-        "CASE WHEN total_cost IS NULL THEN 1 ELSE 0 END ASC, total_cost DESC, #{DEFAULT_ORDER}"
-      when "input"
-        "input_tokens DESC, #{DEFAULT_ORDER}"
-      when "output"
-        "output_tokens DESC, #{DEFAULT_ORDER}"
-      when "slow"
-        "CASE WHEN latency_ms IS NULL THEN 1 ELSE 0 END ASC, latency_ms DESC, #{DEFAULT_ORDER}"
-      else
-        DEFAULT_ORDER
+    def calls_order(sort, dir)
+      column = SORT_OPTIONS.include?(sort) ? sort.to_sym : :tracked_at
+      natural = %i[provider model].include?(column) ? :asc : :desc
+      direction = Dashboard::Sort::DIRECTIONS.include?(dir.downcase) ? dir.downcase.to_sym : natural
+
+      case column
+      when :tracked_at then [{ tracked_at: direction, id: direction }]
+      when :provider   then [{ provider: direction, model: :asc, **DEFAULT_TIEBREAKER }]
+      when :model      then [{ model: direction, **DEFAULT_TIEBREAKER }]
+      when :input      then [{ input_tokens: direction, **DEFAULT_TIEBREAKER }]
+      when :output     then [{ output_tokens: direction, **DEFAULT_TIEBREAKER }]
+      when :cost       then [NULLS_LAST_GUARD[:total_cost], { total_cost: direction, **DEFAULT_TIEBREAKER }]
+      when :latency    then [NULLS_LAST_GUARD[:latency_ms], { latency_ms: direction, **DEFAULT_TIEBREAKER }]
       end
     end
 
@@ -76,7 +83,7 @@ module LlmCostTracker
 
     def csv_fields
       %i[tracked_at provider model] +
-        TokenUsage.members +
+        Usage::TokenUsage.members +
         %i[
           total_cost cost_status pricing_snapshot latency_ms provider_response_id provider_project_id
           provider_api_key_id provider_workspace_id batch tags
@@ -86,15 +93,15 @@ module LlmCostTracker
     def csv_value(field, call)
       case field
       when :tracked_at
-        call.tracked_at&.utc&.iso8601
+        call.tracked_at.utc.iso8601
       when :provider_api_key_id, :provider_workspace_id, :provider_project_id
-        csv_safe(LlmCostTracker::Masking.mask_value(field, call[field]))
+        csv_safe(LlmCostTracker::Dashboard::Masking.mask_value(field, call[field]))
       when :provider, :model, :provider_response_id, :cost_status
         csv_safe(call[field])
       when :pricing_snapshot
         csv_safe(csv_json(call.pricing_snapshot))
       when :tags
-        csv_safe(call.parsed_tags.to_json)
+        csv_safe(call.tag_pairs.to_json)
       else
         call[field]
       end

data/app/controllers/llm_cost_tracker/dashboard_controller.rb

@@ -3,9 +3,6 @@
 module LlmCostTracker
   class DashboardController < ApplicationController
     def index
-      range = Dashboard::DateRange.call(params: params)
-      @from_date = range.from
-      @to_date = range.to
       prev_from, prev_to = previous_range
       filter_params = LlmCostTracker::Dashboard::Params.to_hash(params)
       scope = Dashboard::Filter.call(
@@ -16,7 +13,7 @@ module LlmCostTracker
       )
 
       @stats = Dashboard::OverviewStats.call(scope: scope, previous_scope: previous_scope)
-      @monthly_budget_status = Dashboard::OverviewStats.monthly_budget_status
+      @monthly_budget_status = Dashboard::MonthlyBudget.status
       @time_series = Dashboard::TimeSeries.call(scope: scope, from: @from_date, to: @to_date)
       @comparison_series = Dashboard::TimeSeries.call(scope: previous_scope, from: prev_from, to: prev_to)
       @spend_anomaly = Dashboard::SpendAnomaly.call(from: @from_date, to: @to_date, scope: scope)

data/app/controllers/llm_cost_tracker/models_controller.rb

@@ -4,10 +4,12 @@ module LlmCostTracker
   class ModelsController < ApplicationController
     def index
       @sort = params[:sort].to_s
+      @dir = params[:dir].to_s
       @rows = Dashboard::TopModels.call(
         scope: Dashboard::Filter.call(params: params),
         limit: nil,
-        sort: @sort
+        sort: @sort,
+        direction: @dir
       )
     end
   end

data/app/controllers/llm_cost_tracker/pricing_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class PricingController < ApplicationController
+    def index
+      @overview = Dashboard::PricingOverview.call
+      requested = params[:source]&.to_sym
+      @active_source = @overview.fetch(:sources).key?(requested) ? requested : @overview.fetch(:effective_source)
+      @source_data = @overview.fetch(:sources).fetch(@active_source)
+      @provider_filter = params[:provider].to_s.presence
+      @rows = @source_data.fetch(:rows)
+      @rows = @rows.select { |row| row.provider == @provider_filter } if @provider_filter
+      @providers = @source_data.fetch(:rows).map(&:provider).compact.uniq.sort
+    end
+  end
+end

data/app/controllers/llm_cost_tracker/tags_controller.rb

@@ -11,7 +11,9 @@ module LlmCostTracker
       @value = params[:tag_value].to_s
 
       if @value.empty?
-        @breakdown = Dashboard::TagBreakdown.call(scope: scope, key: params[:key])
+        @sort = params[:sort].to_s
+        @dir = params[:dir].to_s
+        @breakdown = Dashboard::TagBreakdown.call(scope: scope, key: params[:key], sort: @sort, direction: @dir)
       else
         @key = LlmCostTracker::Tags::Key.validate!(
           params[:key],

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -7,7 +7,6 @@ module LlmCostTracker
     TAG_VALUE_SUMMARY_BYTES = 80
     TAG_TOOLTIP_BYTES = 512
 
-    include DashboardFilterHelper
     include DashboardFilterOptionsHelper
     include DashboardQueryHelper
     include ChartHelper
@@ -15,6 +14,17 @@ module LlmCostTracker
     include TokenUsageHelper
     include InlineStyleHelper
 
+    def dashboard_section
+      path = request.path.to_s
+      return :models if path.start_with?(models_path)
+      return :calls if path.start_with?(calls_path)
+      return :tags if path.start_with?(tags_path)
+      return :data_quality if path.start_with?(data_quality_path)
+      return :pricing if path.start_with?(pricing_path)
+
+      :overview
+    end
+
     def coverage_percent(numerator, denominator)
       denominator = denominator.to_f
       return 0.0 unless denominator.positive?
@@ -33,27 +43,20 @@ module LlmCostTracker
       value.nil? ? "n/a" : money(value)
     end
 
-    def optional_number(value)
-      value.nil? ? "n/a" : number(value)
-    end
-
-    def number(value)
-      number_with_delimiter(value)
-    end
-
     def format_date(value)
-      value.try(:strftime, "%Y-%m-%d %H:%M") || value.to_s
+      return "" if value.nil?
+
+      value.strftime("%Y-%m-%d %H:%M")
     end
 
     def pricing_status(call)
-      return "Unknown pricing" if call.total_cost.nil?
-      return "Estimated" unless call.has_attribute?(:cost_status)
+      return "Unknown" if call.total_cost.nil?
 
       {
-        LlmCostTracker::Billing::CostStatus::COMPLETE => "Estimated",
-        LlmCostTracker::Billing::CostStatus::FREE => "Free",
-        LlmCostTracker::Billing::CostStatus::PARTIAL => "Partial pricing"
-      }.fetch(call.cost_status, "Unknown pricing")
+        LlmCostTracker::Charges::CostStatus::COMPLETE => "Estimated",
+        LlmCostTracker::Charges::CostStatus::FREE => "Free",
+        LlmCostTracker::Charges::CostStatus::PARTIAL => "Partial"
+      }.fetch(call.cost_status, "Unknown")
     end
 
     def percent(value)

data/app/helpers/llm_cost_tracker/chart_helper.rb

@@ -6,7 +6,7 @@ module LlmCostTracker
       return nil if points.blank?
 
       cfg = chart_config(points, comparison_points, height, y_ticks)
-      parts = [chart_svg_open(cfg)]
+      parts = [chart_svg_open(cfg), "<title>Daily spend trend</title>", chart_area_gradient_def]
       parts.concat(chart_grid_and_axis(cfg))
       parts << chart_paths(cfg)
       parts.concat(chart_dots(cfg))
@@ -22,7 +22,7 @@ module LlmCostTracker
     end
 
     def chart_config(points, comparison_points, height, y_ticks)
-      width = 720
+      width = 1180
       pad = { top: 16, right: 16, bottom: 28, left: 56 }
       plot_w = width - pad[:left] - pad[:right]
       plot_h = height - pad[:top] - pad[:bottom]
@@ -31,9 +31,11 @@ module LlmCostTracker
       coords = chart_coords(points, pad, plot_w, plot_h, max_cost)
       comparison_coords = chart_coords(comparison_points, pad, plot_w, plot_h, max_cost) if comparison_points.present?
 
+      peak_index = points.each_with_index.max_by { |point, _| point[:cost].to_f }&.last
       { width: width, height: height, pad: pad, plot_w: plot_w, plot_h: plot_h,
         max_cost: max_cost, n: points.size, y_ticks: y_ticks, points: points, coords: coords,
-        comparison_points: comparison_points, comparison_coords: comparison_coords }
+        comparison_points: comparison_points, comparison_coords: comparison_coords,
+        peak_index: peak_index }
     end
 
     def chart_coords(points, pad, plot_w, plot_h, max_cost)
@@ -51,7 +53,7 @@ module LlmCostTracker
       attrs = [
         %(class="lct-chart"),
         %(viewBox="0 0 #{cfg[:width]} #{cfg[:height]}"),
-        %(preserveAspectRatio="none"),
+        %(preserveAspectRatio="xMidYMid meet"),
         %(role="img"),
         %(aria-label="Daily spend trend")
       ].join(" ")
@@ -114,10 +116,20 @@ module LlmCostTracker
     def chart_dot(cfg, pt_x, pt_y, idx)
       point = cfg[:points][idx]
       title = ERB::Util.html_escape("#{point[:label]}: #{money(point[:cost])}")
-      circle = %(<circle class="lct-chart-dot" cx="#{chart_fmt(pt_x)}" cy="#{chart_fmt(pt_y)}" r="3"/>)
+      peak = idx == cfg[:peak_index]
+      klass = peak ? "lct-chart-peak" : "lct-chart-dot"
+      radius = peak ? 4 : 3
+      circle = %(<circle class="#{klass}" cx="#{chart_fmt(pt_x)}" cy="#{chart_fmt(pt_y)}" r="#{radius}"/>)
       "<g>#{circle}<title>#{title}</title></g>"
     end
 
+    def chart_area_gradient_def
+      "<defs><linearGradient id=\"lct-chart-grad\" x1=\"0\" x2=\"0\" y1=\"0\" y2=\"1\">" \
+        "<stop offset=\"0%\" stop-color=\"var(--lct-accent)\" stop-opacity=\"0.28\"/>" \
+        "<stop offset=\"100%\" stop-color=\"var(--lct-accent)\" stop-opacity=\"0.02\"/>" \
+        "</linearGradient></defs>"
+    end
+
     def chart_x_labels(cfg)
       indexes = cfg[:n] <= 2 ? (0...cfg[:n]).to_a : [0, cfg[:n] / 2, cfg[:n] - 1].uniq
       label_y = chart_fmt(cfg[:height] - 8)
@@ -127,7 +139,11 @@ module LlmCostTracker
     def chart_x_label(cfg, idx, label_y)
       pt_x, = cfg[:coords][idx]
       label = ERB::Util.html_escape(cfg[:points][idx][:label])
-      %(<text class="lct-chart-axis" x="#{chart_fmt(pt_x)}" y="#{label_y}" text-anchor="middle">#{label}</text>)
+      anchor = if idx.zero? then "start"
+               elsif idx == cfg[:n] - 1 then "end"
+               else "middle"
+               end
+      %(<text class="lct-chart-axis" x="#{chart_fmt(pt_x)}" y="#{label_y}" text-anchor="#{anchor}">#{label}</text>)
     end
   end
 end

data/app/helpers/llm_cost_tracker/dashboard_filter_options_helper.rb

@@ -4,17 +4,7 @@ module LlmCostTracker
   module DashboardFilterOptionsHelper
     MAX_FILTER_OPTIONS = 100
 
-    def provider_filter_options(filter_params: params)
-      filter_options_for(:provider, filter_params: filter_params)
-    end
-
-    def model_filter_options(filter_params: params)
-      filter_options_for(:model, filter_params: filter_params)
-    end
-
-    private
-
-    def filter_options_for(column, filter_params:)
+    def filter_options_for(column, filter_params: params)
       source = LlmCostTracker::Dashboard::Params.to_hash(filter_params).symbolize_keys
       scope_params = source.merge(
         column => nil, format: nil, page: nil, per: nil, sort: nil

data/app/helpers/llm_cost_tracker/sortable_table_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module SortableTableHelper
+    def sortable_header(label, column, num: false, default: false)
+      state = sortable_state(column, num: num, default: default)
+      classes = ["lct-sortable"]
+      classes << "lct-num" if num
+      classes << "lct-sorted" if state[:active]
+
+      href = dashboard_filter_path(current_query(sort: column, dir: state[:next_dir], page: nil))
+      tag.th(class: classes.join(" "), "aria-sort": state[:aria_sort]) do
+        link_to(href) { safe_join([label, " ", tag.span(state[:arrow], class: "lct-sort-ind")]) }
+      end
+    end
+
+    private
+
+    def sortable_state(column, num:, default: false)
+      current_sort = params[:sort].presence || (default ? column : nil)
+      current_dir = Dashboard::Sort::DIRECTIONS.include?(params[:dir].to_s) ? params[:dir].to_s : nil
+      natural_dir = num ? "desc" : "asc"
+      active = current_sort == column
+      effective_dir = active ? (current_dir || natural_dir) : natural_dir
+      flipped = effective_dir == "asc" ? "desc" : "asc"
+
+      {
+        active: active,
+        next_dir: active ? flipped : natural_dir,
+        arrow: active && effective_dir == "asc" ? "▲" : "▼",
+        aria_sort: sortable_aria(active, effective_dir)
+      }
+    end
+
+    def sortable_aria(active, effective_dir)
+      return "none" unless active
+
+      effective_dir == "asc" ? "ascending" : "descending"
+    end
+  end
+end

data/app/helpers/llm_cost_tracker/token_usage_helper.rb

@@ -40,11 +40,9 @@ module LlmCostTracker
 
     def call_line_item_costs_by_component(call)
       call.line_items.each_with_object({}) do |line_item, accumulator|
-        component = LlmCostTracker::Billing::Components::TOKEN_PRICED.find do |item|
-          item.kind.to_s == line_item.kind.to_s &&
-            item.direction.to_s == line_item.direction.to_s &&
-            item.cache_state.to_s == line_item.cache_state.to_s
-        end
+        component = LlmCostTracker::Usage::Catalog.token_priced_for(
+          kind: line_item.kind, direction: line_item.direction, cache_state: line_item.cache_state
+        )
         accumulator[component.key] = line_item.cost if component && line_item.cost
       end
     end
@@ -52,7 +50,7 @@ module LlmCostTracker
     private
 
     def token_usage_display_components(labels:)
-      LlmCostTracker::Billing::Components::TOKEN_PRICED.map do |component|
+      LlmCostTracker::Usage::Catalog.token_priced.map do |component|
         token_key = component.token_key
         {
           token_key: token_key,

data/app/models/llm_cost_tracker/call.rb

@@ -2,43 +2,26 @@
 
 require "securerandom"
 
-require "llm_cost_tracker/billing/cost_status"
-require "llm_cost_tracker/ledger/schema/adapter"
-require "llm_cost_tracker/ledger/tags/sql"
-
 module LlmCostTracker
   class Call < ActiveRecord::Base
     before_validation :assign_event_id
 
-    PERIOD_FORMATS = {
-      day: {
-        postgres: "YYYY-MM-DD",
-        mysql: "%Y-%m-%d"
-      },
-      month: {
-        postgres: "YYYY-MM",
-        mysql: "%Y-%m"
-      }
-    }.freeze
-
-    private_constant :PERIOD_FORMATS
-
     scope :with_cost, -> { where.not(total_cost: nil) }
     scope :without_cost, -> { where(total_cost: nil) }
-    scope :unknown_pricing, lambda {
-      where(total_cost: nil).or(
-        where(cost_status: [Billing::CostStatus::UNKNOWN, Billing::CostStatus::PARTIAL])
-      )
-    }
+    scope :unknown_pricing,
+          lambda {
+            where(Charges::CostStatus.unknown_pricing_sql)
+          }
     scope :with_latency, -> { where.not(latency_ms: nil) }
     scope :streaming,     -> { where(stream: true) }
     scope :non_streaming, -> { where(stream: [false, nil]) }
     scope :by_usage_source, ->(source) { where(usage_source: source.to_s) }
     scope :with_provider_response_id, -> { where.not(provider_response_id: [nil, ""]) }
     scope :missing_provider_response_id, -> { where(provider_response_id: [nil, ""]) }
-    scope :streaming_missing_usage, lambda {
-      where(stream: true).where(usage_source: ["unknown", nil])
-    }
+    scope :streaming_missing_usage,
+          lambda {
+            where(stream: true).where(usage_source: [Usage::Source::UNKNOWN, nil])
+          }
 
     has_many :line_items,
              class_name: "LlmCostTracker::CallLineItem",
@@ -58,6 +41,12 @@ module LlmCostTracker
     scope :between,     ->(from, to) { where(tracked_at: from..to) }
 
     class << self
+      def already_recorded?(provider:, provider_response_id:)
+        return false if provider_response_id.to_s.empty?
+
+        where(provider: provider, provider_response_id: provider_response_id).exists?
+      end
+
       def by_tag(key, value) = by_tags(key => value)
 
       def by_tags(tags) = Ledger::Tags::Query.apply(tags)
@@ -71,20 +60,20 @@ module LlmCostTracker
       def cost_by_provider(limit: nil) = cost_by_column(:provider, limit: limit)
 
       def group_by_tag(key)
-        Ledger::Tags::Sql.join_relation(self, key).group(Ledger::Tags::Sql.value_arel)
+        Ledger::Tags::Breakdown.join_relation(self, key).group(Ledger::Tags::Breakdown.value_arel)
       end
 
       def cost_by_tag(key, limit: nil)
-        label = Ledger::Tags::Sql.label_sql(connection)
-        raw_value = Ledger::Tags::Sql.raw_value_sql(connection)
-        relation = Ledger::Tags::Sql.join_relation(self, key)
-                                    .select("#{label} AS name", "COALESCE(SUM(total_cost), 0) AS total_cost")
-                                    .group(Arel.sql(label))
-                                    .order(
-                                      Arel.sql("COALESCE(SUM(total_cost), 0) DESC"),
-                                      Arel.sql("MAX(CASE WHEN #{raw_value} IS NULL THEN 1 ELSE 0 END) ASC"),
-                                      Arel.sql("#{label} DESC")
-                                    )
+        label = Ledger::Tags::Breakdown.label_sql(connection)
+        raw_value = Ledger::Tags::Breakdown.raw_value_sql(connection)
+        relation = Ledger::Tags::Breakdown.join_relation(self, key)
+                                          .select("#{label} AS name", "COALESCE(SUM(total_cost), 0) AS total_cost")
+                                          .group(Arel.sql(label))
+                                          .order(
+                                            Arel.sql("COALESCE(SUM(total_cost), 0) DESC"),
+                                            Arel.sql("MAX(CASE WHEN #{raw_value} IS NULL THEN 1 ELSE 0 END) ASC"),
+                                            Arel.sql("#{label} DESC")
+                                          )
         relation = relation.limit(limit) if limit
         relation
       end
@@ -108,8 +97,7 @@ module LlmCostTracker
       private
 
       def cost_by_column(column, limit:)
-        quoted_column = "#{quoted_table_name}.#{connection.quote_column_name(column)}"
-        relation = select("#{quoted_column} AS name, COALESCE(SUM(total_cost), 0) AS total_cost")
+        relation = select(arel_table[column].as("name"), "COALESCE(SUM(total_cost), 0) AS total_cost")
                    .group(column)
                    .order(Arel.sql("COALESCE(SUM(total_cost), 0) DESC"))
         relation = relation.limit(limit) if limit
@@ -117,30 +105,7 @@ module LlmCostTracker
       end
 
       def period_group_expression(period, column:)
-        period = validated_period(period)
-        column = period_column_expression(column)
-        formats = PERIOD_FORMATS.fetch(period)
-
-        if Ledger::Schema::Adapter.postgresql?(connection)
-          postgres_period_expression(period, column, formats)
-        elsif Ledger::Schema::Adapter.mysql?(connection)
-          "DATE_FORMAT(#{column}, #{connection.quote(formats.fetch(:mysql))})"
-        else
-          Ledger::Schema::Adapter.ensure_supported!(connection)
-        end
-      end
-
-      def postgres_period_expression(period, column, formats)
-        "TO_CHAR(" \
-          "DATE_TRUNC(#{connection.quote(period.name)}, #{column}), " \
-          "#{connection.quote(formats.fetch(:postgres))}" \
-          ")"
-      end
-
-      def validated_period(period)
-        return period if PERIOD_FORMATS.key?(period)
-
-        raise ArgumentError, "invalid period: #{period.inspect}"
+        Ledger::Schema::Adapter.period_bucket_sql(connection, period, period_column_expression(column))
       end
 
       def period_column_expression(column)
@@ -151,7 +116,7 @@ module LlmCostTracker
       end
     end
 
-    def parsed_tags
+    def tag_pairs
       tag_records.to_h do |record|
         [record.key, record.value]
       end

data/app/models/llm_cost_tracker/call_line_item.rb

@@ -12,7 +12,7 @@ module LlmCostTracker
     scope :by_direction, ->(direction) { where(direction: direction.to_s) }
     scope :by_modality, ->(modality) { where(modality: modality.to_s) }
     scope :cached, -> { where.not(cache_state: ["none", nil]) }
-    scope :priced, -> { where(cost_status: %w[complete free]) }
-    scope :unpriced, -> { where(cost_status: "unknown") }
+    scope :priced, -> { where(cost_status: [Charges::CostStatus::COMPLETE, Charges::CostStatus::FREE]) }
+    scope :unpriced, -> { where(cost_status: Charges::CostStatus::UNKNOWN) }
   end
 end

data/app/models/llm_cost_tracker/call_rollup.rb

@@ -2,5 +2,43 @@
 
 module LlmCostTracker
   class CallRollup < ActiveRecord::Base
+    class << self
+      def increment_all(rows)
+        upsert_all(rows, on_duplicate: increment_on_duplicate, record_timestamps: true, unique_by: increment_unique_by)
+      end
+
+      def decrement(buckets)
+        now = Time.now.utc
+        buckets.each do |(period, period_start, currency, provider), amount|
+          where(period: period, period_start: period_start, currency: currency, provider: provider)
+            .update_all(["total_cost = GREATEST(0, total_cost - ?), updated_at = ?", amount, now])
+        end
+      end
+
+      private
+
+      def increment_on_duplicate
+        return Arel.sql(mysql_increment_sql) if Ledger::Schema::Adapter.mysql?(connection)
+        return Arel.sql(postgres_increment_sql) if Ledger::Schema::Adapter.postgresql?(connection)
+
+        Ledger::Schema::Adapter.ensure_supported!(connection)
+      end
+
+      def postgres_increment_sql
+        total = connection.quote_column_name("total_cost")
+        updated = connection.quote_column_name("updated_at")
+        "#{total} = #{quoted_table_name}.#{total} + excluded.#{total}, #{updated} = excluded.#{updated}"
+      end
+
+      def mysql_increment_sql
+        "total_cost = total_cost + VALUES(total_cost), updated_at = VALUES(updated_at)"
+      end
+
+      def increment_unique_by
+        return unless connection.supports_insert_conflict_target?
+
+        %i[period period_start currency provider]
+      end
+    end
   end
 end

data/app/models/llm_cost_tracker/call_tag.rb

@@ -6,7 +6,5 @@ module LlmCostTracker
                class_name: "LlmCostTracker::Call",
                foreign_key: :llm_cost_tracker_call_id,
                inverse_of: :tag_records
-
-    scope :with_key, ->(key) { where(key: key.to_s) }
   end
 end

data/app/models/llm_cost_tracker/ingestion/inbox_entry.rb

@@ -4,6 +4,8 @@ module LlmCostTracker
   module Ingestion
     class InboxEntry < ActiveRecord::Base
       MAX_ATTEMPTS_BEFORE_QUARANTINE = 5
+
+      scope :pending, -> { where(attempts: ..(MAX_ATTEMPTS_BEFORE_QUARANTINE - 1)) }
     end
   end
 end