#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use crate::error::RouterError;
use crate::pricing::ModelPricing;
const COST_SCALE: f64 = 10_000.0;
#[derive(Debug, Clone)]
pub struct CostTracker {
total_cost: Arc<AtomicU64>,
total_input_tokens: Arc<AtomicU64>,
total_output_tokens: Arc<AtomicU64>,
per_model: Arc<Mutex<BTreeMap<String, ModelCostRecord>>>,
budget_limit_usd: Option<f64>,
}
#[derive(Debug, Clone, Default)]
struct ModelCostRecord {
input_tokens: u64,
output_tokens: u64,
cost_fixed: u64,
request_count: u64,
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ModelCostBreakdown {
pub input_tokens: u64,
pub output_tokens: u64,
pub cost_usd: f64,
pub request_count: u64,
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct CostReport {
pub total_cost_usd: f64,
pub total_input_tokens: u64,
pub total_output_tokens: u64,
pub per_model: BTreeMap<String, ModelCostBreakdown>,
pub budget_limit_usd: Option<f64>,
pub is_over_budget: bool,
}
impl CostTracker {
pub fn new(budget_limit_usd: Option<f64>) -> Self {
Self {
total_cost: Arc::new(AtomicU64::new(0)),
total_input_tokens: Arc::new(AtomicU64::new(0)),
total_output_tokens: Arc::new(AtomicU64::new(0)),
per_model: Arc::new(Mutex::new(BTreeMap::new())),
budget_limit_usd,
}
}
pub fn budget_limit_usd(&self) -> Option<f64> {
self.budget_limit_usd
}
pub fn record(
&self,
model: &str,
input_tokens: usize,
output_tokens: usize,
pricing: &ModelPricing,
) -> Result<(), RouterError> {
let cost_usd = pricing.cost(input_tokens, output_tokens);
let cost_fixed = (cost_usd * COST_SCALE) as u64;
if let Some(limit) = self.budget_limit_usd {
let current = self.total_usd();
if current + cost_usd > limit {
return Err(RouterError::BudgetExceeded {
current,
attempted: cost_usd,
limit,
});
}
}
self.total_cost.fetch_add(cost_fixed, Ordering::Relaxed);
self.total_input_tokens
.fetch_add(input_tokens as u64, Ordering::Relaxed);
self.total_output_tokens
.fetch_add(output_tokens as u64, Ordering::Relaxed);
#[allow(clippy::expect_used)]
let mut per_model = self.per_model.lock().expect("cost tracker mutex poisoned");
let record = per_model.entry(model.to_string()).or_default();
record.input_tokens += input_tokens as u64;
record.output_tokens += output_tokens as u64;
record.cost_fixed += cost_fixed;
record.request_count += 1;
Ok(())
}
pub fn total_usd(&self) -> f64 {
self.total_cost.load(Ordering::Relaxed) as f64 / COST_SCALE
}
pub fn total_input_tokens(&self) -> u64 {
self.total_input_tokens.load(Ordering::Relaxed)
}
pub fn total_output_tokens(&self) -> u64 {
self.total_output_tokens.load(Ordering::Relaxed)
}
pub fn remaining_usd(&self) -> Option<f64> {
self.budget_limit_usd
.map(|limit| (limit - self.total_usd()).max(0.0))
}
pub fn per_model_breakdown(&self) -> BTreeMap<String, ModelCostBreakdown> {
#[allow(clippy::expect_used)]
let per_model = self.per_model.lock().expect("cost tracker mutex poisoned");
per_model
.iter()
.map(|(model, record)| {
(
model.clone(),
ModelCostBreakdown {
input_tokens: record.input_tokens,
output_tokens: record.output_tokens,
cost_usd: record.cost_fixed as f64 / COST_SCALE,
request_count: record.request_count,
},
)
})
.collect()
}
pub fn is_over_budget(&self) -> bool {
match self.budget_limit_usd {
Some(limit) => self.total_usd() >= limit,
None => false,
}
}
pub fn report(&self) -> CostReport {
CostReport {
total_cost_usd: self.total_usd(),
total_input_tokens: self.total_input_tokens(),
total_output_tokens: self.total_output_tokens(),
per_model: self.per_model_breakdown(),
budget_limit_usd: self.budget_limit_usd,
is_over_budget: self.is_over_budget(),
}
}
}