llm_cost_tracker 0.14.2 → 0.15.0

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -6,6 +6,12 @@ module LlmCostTracker
   module ApplicationHelper
     TAG_VALUE_SUMMARY_BYTES = 80
     TAG_TOOLTIP_BYTES = 512
+    PRICING_STATUS_LABELS = {
+      LlmCostTracker::Charges::CostStatus::COMPLETE => "Estimated",
+      LlmCostTracker::Charges::CostStatus::FREE => "Free",
+      LlmCostTracker::Charges::CostStatus::PARTIAL => "Partial"
+    }.freeze
+    NEUTRAL_DELTA_CLASS = "lct-delta-badge lct-delta-neutral"
 
     include DashboardFilterOptionsHelper
     include DashboardQueryHelper
@@ -26,11 +32,13 @@ module LlmCostTracker
       :overview
     end
 
-    def coverage_percent(numerator, denominator)
-      denominator = denominator.to_f
-      return 0.0 unless denominator.positive?
+    def sidebar_link_options(section)
+      active = dashboard_section == section
+      { class: active ? "lct-sidebar-link lct-active" : "lct-sidebar-link", aria: active ? { current: "page" } : {} }
+    end
 
-      (numerator.to_f / denominator) * 100.0
+    def coverage_percent(numerator, denominator)
+      Dashboard::Percent.of(numerator, denominator)
     end
 
     def money(value, currency: LlmCostTracker::DEFAULT_CURRENCY)
@@ -55,11 +63,7 @@ module LlmCostTracker
     def pricing_status(call)
       return "Unknown" if call.total_cost.nil?
 
-      {
-        LlmCostTracker::Charges::CostStatus::COMPLETE => "Estimated",
-        LlmCostTracker::Charges::CostStatus::FREE => "Free",
-        LlmCostTracker::Charges::CostStatus::PARTIAL => "Partial"
-      }.fetch(call.cost_status, "Unknown")
+      PRICING_STATUS_LABELS.fetch(call.cost_status, "Unknown")
     end
 
     def percent(value)
@@ -67,22 +71,11 @@ module LlmCostTracker
     end
 
     def delta_badge(delta_percent, mode: :cost)
-      return { text: "n/a vs. prior", css_class: "lct-delta-badge lct-delta-neutral" } if delta_percent.nil?
-
-      rounded = delta_percent.round(1)
-      return { text: "0.0% vs. prior", css_class: "lct-delta-badge lct-delta-neutral" } if rounded.zero?
-
-      sign = rounded.positive? ? "+" : ""
-      text = "#{sign}#{format('%.1f', rounded)}% vs. prior"
-      css_class = if mode == :neutral
-                    "lct-delta-badge lct-delta-neutral"
-                  elsif rounded.positive?
-                    "lct-delta-badge lct-delta-up"
-                  else
-                    "lct-delta-badge lct-delta-down"
-                  end
+      rounded = delta_percent&.round(1)
+      return { text: "n/a vs. prior", css_class: NEUTRAL_DELTA_CLASS } if rounded.nil?
+      return { text: "0.0% vs. prior", css_class: NEUTRAL_DELTA_CLASS } if rounded.zero?
 
-      { text: text, css_class: css_class }
+      { text: "#{format('%+.1f', rounded)}% vs. prior", css_class: delta_badge_class(rounded, mode) }
     end
 
     def bar_width(value, max)
@@ -132,15 +125,13 @@ module LlmCostTracker
       truncate_text(safe_json(tags), TAG_TOOLTIP_BYTES)
     end
 
-    def current_query(overrides = {})
-      request.query_parameters.symbolize_keys.slice(*LlmCostTracker::Dashboard::Params::QUERY_KEYS).merge(overrides)
-    end
+    private
 
-    def calls_query_for_model(provider:, model:)
-      current_query(provider: provider, model: model, page: nil, per: nil, format: nil)
-    end
+    def delta_badge_class(rounded, mode)
+      return NEUTRAL_DELTA_CLASS if mode == :neutral
 
-    private
+      rounded.positive? ? "lct-delta-badge lct-delta-up" : "lct-delta-badge lct-delta-down"
+    end
 
     def truncate_text(string, limit)
       return string if string.bytesize <= limit

data/app/helpers/llm_cost_tracker/chart_helper.rb

@@ -2,17 +2,27 @@
 
 module LlmCostTracker
   module ChartHelper
+    CHART_OPEN_TAG = "<svg class=\"lct-chart\" viewBox=\"0 0 %<width>s %<height>s\" " \
+                     "preserveAspectRatio=\"xMidYMid meet\" role=\"img\" aria-label=\"Daily spend trend\">"
+    CHART_GRADIENT = "<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>"
+
     def spend_chart_svg(points, comparison_points: nil, height: 180, y_ticks: 3)
       return nil if points.blank?
 
-      cfg = chart_config(points, comparison_points, height, y_ticks)
-      parts = [chart_svg_open(cfg), "<title>Daily spend trend</title>", chart_area_gradient_def]
-      parts.concat((0..cfg[:y_ticks]).map { |i| chart_tick_line(cfg, i) })
-      parts << chart_paths(cfg)
-      parts.concat(chart_dots(cfg))
-      parts.concat(chart_x_labels(cfg))
-      parts << "</svg>"
-      parts.join.html_safe
+      chart = Dashboard::SpendChart.new(points, comparison_points: comparison_points, height: height, y_ticks: y_ticks)
+      [
+        format(CHART_OPEN_TAG, width: Dashboard::SpendChart::WIDTH, height: chart.height),
+        "<title>Daily spend trend</title>",
+        CHART_GRADIENT,
+        *(0..chart.y_ticks).map { |index| chart_tick(chart, index) },
+        chart_paths(chart),
+        *chart.coords.each_index.map { |index| chart_dot(chart, index) },
+        *chart.label_indexes.map { |index| chart_x_label(chart, index) },
+        "</svg>"
+      ].join.html_safe
     end
 
     private
@@ -21,125 +31,64 @@ module LlmCostTracker
       format("%.2f", value)
     end
 
-    def chart_config(points, comparison_points, height, y_ticks)
-      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]
-      all_costs = points.map { |p| p[:cost].to_f } + Array(comparison_points).map { |p| p[:cost].to_f }
-      max_cost = [all_costs.max.to_f, 0.0001].max
-      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_coords: comparison_coords,
-        peak_index: peak_index }
-    end
-
-    def chart_coords(points, pad, plot_w, plot_h, max_cost)
-      n = points.size
-      step = n > 1 ? plot_w.to_f / (n - 1) : 0.0
-
-      points.each_with_index.map do |point, idx|
-        x = pad[:left] + (idx * step)
-        y = pad[:top] + plot_h - ((point[:cost].to_f / max_cost) * plot_h)
-        [x, y]
-      end
-    end
-
-    def chart_svg_open(cfg)
-      attrs = [
-        %(class="lct-chart"),
-        %(viewBox="0 0 #{cfg[:width]} #{cfg[:height]}"),
-        %(preserveAspectRatio="xMidYMid meet"),
-        %(role="img"),
-        %(aria-label="Daily spend trend")
-      ].join(" ")
-      "<svg #{attrs}>"
+    def chart_element(name, attributes, content = nil)
+      attrs = attributes.map { |key, value| %( #{key}="#{value}") }.join
+      content.nil? ? "<#{name}#{attrs}/>" : "<#{name}#{attrs}>#{content}</#{name}>"
     end
 
-    def chart_tick_line(cfg, idx)
-      pad = cfg[:pad]
-      right_x = chart_fmt(pad[:left] + cfg[:plot_w])
-      left_x = chart_fmt(pad[:left])
-      text_x = chart_fmt(pad[:left] - 8)
-      value = cfg[:max_cost] * (cfg[:y_ticks] - idx).to_f / cfg[:y_ticks]
-      tick_y = pad[:top] + (cfg[:plot_h] * idx.to_f / cfg[:y_ticks])
+    def chart_tick(chart, index)
+      tick_y = chart.tick_y(index)
       y = chart_fmt(tick_y)
-      label_y = chart_fmt(tick_y + 3)
-      grid = %(<line class="lct-chart-grid" x1="#{left_x}" x2="#{right_x}" y1="#{y}" y2="#{y}"/>)
-      text = %(<text class="lct-chart-axis" x="#{text_x}" y="#{label_y}" text-anchor="end">$#{chart_fmt(value)}</text>)
-      "#{grid}#{text}"
+      grid = { class: "lct-chart-grid", x1: chart_fmt(chart.left), x2: chart_fmt(chart.right), y1: y, y2: y }
+      label = { class: "lct-chart-axis", x: chart_fmt(chart.left - 8), y: chart_fmt(tick_y + 3), "text-anchor": "end" }
+      chart_element(:line, grid) + chart_element(:text, label, "$#{chart_fmt(chart.tick_value(index))}")
     end
 
-    def chart_paths(cfg)
-      line = build_line_path(cfg[:coords])
-      base_y = cfg[:pad][:top] + cfg[:plot_h]
-      area = build_area_path(cfg[:coords], cfg, base_y, line)
-      secondary = if cfg[:comparison_coords].present?
-                    %(<path class="lct-chart-line-secondary" d="#{build_line_path(cfg[:comparison_coords])}"/>)
-                  else
-                    ""
-                  end
-      %(<path class="lct-chart-area" d="#{area}"/>#{secondary}<path class="lct-chart-line" d="#{line}"/>)
+    def chart_paths(chart)
+      line = chart_line_path(chart.coords)
+      paths = [chart_element(:path, class: "lct-chart-area", d: chart_area_path(chart, line))]
+      if chart.comparison_coords
+        paths << chart_element(:path, class: "lct-chart-line-secondary", d: chart_line_path(chart.comparison_coords))
+      end
+      paths << chart_element(:path, class: "lct-chart-line", d: line)
+      paths.join
     end
 
-    def build_line_path(coords)
-      coords.each_with_index.map do |(x, y), idx|
-        "#{idx.zero? ? 'M' : 'L'}#{chart_fmt(x)},#{chart_fmt(y)}"
+    def chart_line_path(coords)
+      coords.each_with_index.map do |(x, y), index|
+        "#{index.zero? ? 'M' : 'L'}#{chart_fmt(x)},#{chart_fmt(y)}"
       end.join(" ")
     end
 
-    def build_area_path(coords, cfg, base_y, line)
-      if coords.size == 1
-        x, y = coords.first
-        left = chart_fmt(cfg[:pad][:left])
-        right = chart_fmt(cfg[:pad][:left] + cfg[:plot_w])
-        "M#{left},#{chart_fmt(base_y)} L#{chart_fmt(x)},#{chart_fmt(y)} L#{right},#{chart_fmt(base_y)} Z"
-      else
-        first_x = chart_fmt(coords.first[0])
-        last_x = chart_fmt(coords.last[0])
-        "#{line} L#{last_x},#{chart_fmt(base_y)} L#{first_x},#{chart_fmt(base_y)} Z"
-      end
-    end
+    def chart_area_path(chart, line)
+      coords = chart.coords
+      base = chart_fmt(chart.baseline)
+      return "#{line} L#{chart_fmt(coords.last[0])},#{base} L#{chart_fmt(coords.first[0])},#{base} Z" if coords.size > 1
 
-    def chart_dots(cfg)
-      cfg[:coords].each_with_index.map { |(pt_x, pt_y), idx| chart_dot(cfg, pt_x, pt_y, idx) }
+      x, y = coords.first
+      "M#{chart_fmt(chart.left)},#{base} L#{chart_fmt(x)},#{chart_fmt(y)} L#{chart_fmt(chart.right)},#{base} Z"
     end
 
-    def chart_dot(cfg, pt_x, pt_y, idx)
-      point = cfg[:points][idx]
+    def chart_dot(chart, index)
+      point = chart.points[index]
+      x, y = chart.coords[index]
+      peak = index == chart.peak_index
+      circle = { class: peak ? "lct-chart-peak" : "lct-chart-dot", cx: chart_fmt(x), cy: chart_fmt(y), r: peak ? 4 : 3 }
       title = ERB::Util.html_escape("#{point[:label]}: #{money(point[:cost])}")
-      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>"
+      "<g>#{chart_element(:circle, 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>"
+    def chart_x_label(chart, index)
+      x, = chart.coords[index]
+      anchor = chart_label_anchor(chart, index)
+      attributes = { class: "lct-chart-axis", x: chart_fmt(x), y: chart_fmt(chart.height - 8), "text-anchor": anchor }
+      chart_element(:text, attributes, ERB::Util.html_escape(chart.points[index][:label]))
     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)
-      indexes.map { |idx| chart_x_label(cfg, idx, label_y) }
-    end
+    def chart_label_anchor(chart, index)
+      return "start" if index.zero?
 
-    def chart_x_label(cfg, idx, label_y)
-      pt_x, = cfg[:coords][idx]
-      label = ERB::Util.html_escape(cfg[:points][idx][:label])
-      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>)
+      index == chart.points.size - 1 ? "end" : "middle"
     end
   end
 end

data/app/helpers/llm_cost_tracker/dashboard_query_helper.rb

@@ -2,23 +2,33 @@
 
 module LlmCostTracker
   module DashboardQueryHelper
-    def dashboard_filter_path(query)
-      cleaned = clean_dashboard_query(query)
-      return request.path if cleaned.blank?
+    EMPTY_QUERY_VALUES = [nil, {}, []].freeze
 
-      "#{request.path}?#{cleaned.to_query}"
+    def current_query(overrides = {})
+      request.query_parameters.symbolize_keys.slice(*Dashboard::Params::QUERY_KEYS).merge(overrides)
+    end
+
+    def calls_query_for_model(provider:, model:)
+      current_query(provider: provider, model: model, page: nil, per: nil, format: nil)
     end
 
     def calls_query_for_tag(key:, value:)
       query = current_query(page: nil, per: nil, format: nil)
-      tags = LlmCostTracker::Dashboard::Params.tag_query(query[:tag])
+      tags = Dashboard::Params.tag_query(query[:tag])
       query[:tag] = tags.merge(key.to_s => value.to_s)
       query
     end
 
     def tag_drilldown_allowed?(key)
-      tags = LlmCostTracker::Dashboard::Params.tag_query(current_query[:tag])
-      tags.except(key.to_s).size < LlmCostTracker::Dashboard::Filter::MAX_TAG_FILTERS
+      tags = Dashboard::Params.tag_query(current_query[:tag])
+      tags.except(key.to_s).size < Dashboard::Filter::MAX_TAG_FILTERS
+    end
+
+    def dashboard_filter_path(query)
+      cleaned = clean_dashboard_query(query)
+      return request.path if cleaned.blank?
+
+      "#{request.path}?#{cleaned.to_query}"
     end
 
     def hidden_query_fields(query, prefix: nil)
@@ -35,19 +45,22 @@ module LlmCostTracker
     private
 
     def clean_dashboard_query(value)
-      if value.is_a?(Hash) || value.try(:to_unsafe_h).is_a?(Hash)
-        return LlmCostTracker::Dashboard::Params.to_hash(value).each_with_object({}) do |(key, nested), cleaned|
-          nested = clean_dashboard_query(nested)
-          next if nested.nil? || nested == {} || nested == []
-
-          cleaned[key] = nested
-        end
+      case value
+      when Array then value.filter_map { |item| clean_dashboard_query(item) }.presence
+      when String then value.strip.presence
+      else query_hash?(value) ? clean_query_hash(value) : value
       end
+    end
 
-      return value.filter_map { |item| clean_dashboard_query(item) }.presence if value.is_a?(Array)
-      return value.strip.presence if value.is_a?(String)
+    def clean_query_hash(hash)
+      Dashboard::Params.to_hash(hash).each_with_object({}) do |(key, value), cleaned|
+        value = clean_dashboard_query(value)
+        cleaned[key] = value unless EMPTY_QUERY_VALUES.include?(value)
+      end
+    end
 
-      value
+    def query_hash?(value)
+      value.is_a?(Hash) || value.try(:to_unsafe_h).is_a?(Hash)
     end
   end
 end

data/app/helpers/llm_cost_tracker/sortable_table_helper.rb

@@ -2,40 +2,33 @@
 
 module LlmCostTracker
   module SortableTableHelper
+    SORT_ARROWS = { "asc" => "▲", "desc" => "▼" }.freeze
+    ARIA_SORT = { "asc" => "ascending", "desc" => "descending" }.freeze
+
     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")]) }
+      natural = num ? "desc" : "asc"
+      direction = sorted_direction(column, natural, default)
+      classes = ["lct-sortable", ("lct-num" if num), ("lct-sorted" if direction)].compact
+
+      href = dashboard_filter_path(current_query(sort: column, dir: next_sort_direction(direction, natural), page: nil))
+      tag.th(class: classes.join(" "), "aria-sort": ARIA_SORT.fetch(direction, "none")) do
+        link_to(href) { safe_join([label, " ", tag.span(SORT_ARROWS.fetch(direction, "▼"), 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)
-      }
+    def sorted_direction(column, natural, default)
+      return unless (params[:sort].presence || (column if default)) == column
+
+      requested = params[:dir].to_s
+      Dashboard::Sort::DIRECTIONS.include?(requested) ? requested : natural
     end
 
-    def sortable_aria(active, effective_dir)
-      return "none" unless active
+    def next_sort_direction(direction, natural)
+      return natural unless direction
 
-      effective_dir == "asc" ? "ascending" : "descending"
+      direction == "asc" ? "desc" : "asc"
     end
   end
 end

data/app/helpers/llm_cost_tracker/token_usage_helper.rb

@@ -49,5 +49,35 @@ module LlmCostTracker
         call.line_items.map { |item| [item.kind, item.direction, item.cache_state, item.cost] }
       )
     end
+
+    def call_token_segments(call)
+      token_usage_stack_components.map do |component|
+        value = call[component.fetch(:token_key)]
+        token_stack_segment(component, value, number_with_delimiter(value))
+      end
+    end
+
+    def call_cost_segments(call)
+      costs = call_line_item_costs_by_component(call)
+      token_usage_stack_components.map do |component|
+        value = costs[component.fetch(:price_key)]
+        token_stack_segment(component, value, optional_money(value))
+      end
+    end
+
+    def call_service_line_items(call)
+      call.line_items.reject { |item| item.unit == "token" }.sort_by(&:position)
+    end
+
+    private
+
+    def token_stack_segment(component, value, formatted_value)
+      {
+        label: component.fetch(:label),
+        value: value,
+        formatted_value: formatted_value,
+        css_class: component.fetch(:css_class)
+      }
+    end
   end
 end

data/app/models/llm_cost_tracker/call.rb

@@ -69,8 +69,8 @@ module LlmCostTracker
 
       def cost_by_tag(key, limit: nil)
         cost = qualified(:total_cost)
-        label = Ledger::Tags::Breakdown.label_sql(connection)
-        raw_value = Ledger::Tags::Breakdown.raw_value_sql(connection)
+        label = Ledger::Tags::Breakdown.label_sql(lease_connection)
+        raw_value = Ledger::Tags::Breakdown.raw_value_sql(lease_connection)
         relation = Ledger::Tags::Breakdown.join_relation(self, key)
                                           .select("#{label} AS name", "COALESCE(SUM(#{cost}), 0) AS total_cost")
                                           .group(Arel.sql(label))
@@ -93,7 +93,9 @@ module LlmCostTracker
         column = column.to_s
         raise ArgumentError, "invalid period column: #{column.inspect}" unless column_names.include?(column)
 
-        bucket = Ledger::Schema::Adapter.period_bucket_sql(connection, period, qualified(column), time_zone: time_zone)
+        bucket = Ledger::Schema::Adapter.period_bucket_sql(
+          lease_connection, period, qualified(column), time_zone: time_zone
+        )
         group(Arel.sql(bucket))
       end
 
@@ -104,7 +106,7 @@ module LlmCostTracker
       end
 
       def qualified(column)
-        "#{quoted_table_name}.#{connection.quote_column_name(column)}"
+        "#{quoted_table_name}.#{lease_connection.quote_column_name(column)}"
       end
 
       private

data/app/models/llm_cost_tracker/call_rollup.rb

@@ -34,15 +34,15 @@ module LlmCostTracker
       end
 
       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)
+        return Arel.sql(mysql_increment_sql) if Ledger::Schema::Adapter.mysql?(lease_connection)
+        return Arel.sql(postgres_increment_sql) if Ledger::Schema::Adapter.postgresql?(lease_connection)
 
-        Ledger::Schema::Adapter.ensure_supported!(connection)
+        Ledger::Schema::Adapter.ensure_supported!(lease_connection)
       end
 
       def postgres_increment_sql
-        total = connection.quote_column_name("total_cost")
-        updated = connection.quote_column_name("updated_at")
+        total = lease_connection.quote_column_name("total_cost")
+        updated = lease_connection.quote_column_name("updated_at")
         "#{total} = #{quoted_table_name}.#{total} + excluded.#{total}, #{updated} = excluded.#{updated}"
       end
 
@@ -51,7 +51,7 @@ module LlmCostTracker
       end
 
       def increment_unique_by
-        return unless connection.supports_insert_conflict_target?
+        return unless lease_connection.supports_insert_conflict_target?
 
         %i[period period_start currency provider]
       end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module CallOrder
+      NATURAL_DIRECTIONS = {
+        "tracked_at" => "desc",
+        "provider" => "asc",
+        "model" => "asc",
+        "input" => "desc",
+        "output" => "desc",
+        "cost" => "desc",
+        "latency" => "desc"
+      }.freeze
+      NEWEST_FIRST = { tracked_at: :desc, id: :desc }.freeze
+      COST_NULLS_LAST = Arel.sql("CASE WHEN total_cost IS NULL THEN 1 ELSE 0 END ASC")
+      LATENCY_NULLS_LAST = Arel.sql("CASE WHEN latency_ms IS NULL THEN 1 ELSE 0 END ASC")
+      ORDERS = {
+        "tracked_at" => ->(dir) { [{ tracked_at: dir, id: dir }] },
+        "provider" => ->(dir) { [{ provider: dir, model: :asc, **NEWEST_FIRST }] },
+        "model" => ->(dir) { [{ model: dir, **NEWEST_FIRST }] },
+        "input" => ->(dir) { [{ input_tokens: dir, **NEWEST_FIRST }] },
+        "output" => ->(dir) { [{ output_tokens: dir, **NEWEST_FIRST }] },
+        "cost" => ->(dir) { [COST_NULLS_LAST, { total_cost: dir, **NEWEST_FIRST }] },
+        "latency" => ->(dir) { [LATENCY_NULLS_LAST, { latency_ms: dir, **NEWEST_FIRST }] }
+      }.freeze
+
+      def self.call(scope, sort:, direction:)
+        choice = Sort.resolve(
+          sort, direction.to_s.downcase, natural_directions: NATURAL_DIRECTIONS, fallback: "tracked_at"
+        )
+        scope.order(*ORDERS.fetch(choice.column).call(choice.direction.to_sym))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+
+module LlmCostTracker
+  module Dashboard
+    class CallsExport
+      MYSQL_HINT = "NO_SKIP_SCAN(llm_cost_tracker_calls)"
+      FORMULA_PREFIXES = ["=", "+", "-", "@", "\t", "\r"].freeze
+      MASKED_FIELDS = %i[provider_api_key_id provider_workspace_id provider_project_id].freeze
+      TEXT_FIELDS = %i[provider model provider_response_id cost_status].freeze
+      FIELDS = [
+        :tracked_at, :provider, :model, *Usage::TokenUsage.members, :total_cost, :cost_status, :pricing_snapshot,
+        :latency_ms, :provider_response_id, :provider_project_id, :provider_api_key_id, :provider_workspace_id,
+        :batch, :tags
+      ].freeze
+
+      def self.call(relation, limit:, batch_size:)
+        new(relation, limit: limit, batch_size: batch_size).to_s
+      end
+
+      def initialize(relation, limit:, batch_size:)
+        @relation = relation
+        @limit = limit
+        @batch_size = batch_size
+      end
+
+      def to_s
+        CSV.generate do |csv|
+          csv << FIELDS.map(&:to_s)
+          each_call { |call| csv << FIELDS.map { |field| value(field, call) } }
+        end
+      end
+
+      private
+
+      attr_reader :relation, :limit, :batch_size
+
+      def each_call(&block)
+        scope = relation.limit(limit)
+        scope = scope.optimizer_hints(MYSQL_HINT) if Ledger::Schema::Adapter.mysql?(scope.lease_connection)
+        scope.pluck(:id).each_slice(batch_size) do |ids|
+          calls = LlmCostTracker::Call.where(id: ids).preload(:tag_records).index_by(&:id)
+          calls.values_at(*ids).compact.each(&block)
+        end
+      end
+
+      def value(field, call)
+        case field
+        when :tracked_at then call.tracked_at.utc.iso8601
+        when *MASKED_FIELDS then formula_safe(Masking.mask_value(field, call[field]))
+        when *TEXT_FIELDS then formula_safe(call[field])
+        when :pricing_snapshot then formula_safe(Hash(call.pricing_snapshot).deep_stringify_keys.to_json)
+        when :tags then formula_safe(call.tag_pairs.to_json)
+        else call[field]
+        end
+      end
+
+      def formula_safe(value)
+        return if value.nil?
+
+        string = value.to_s
+        FORMULA_PREFIXES.include?(string.lstrip[0]) ? "'#{string}" : string
+      end
+    end
+  end
+end