use std::collections::HashMap;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct HardwareUsage {
#[serde(default)]
pub cpu: u64,
#[serde(default)]
pub payload_io_read: u64,
#[serde(default)]
pub payload_io_write: u64,
#[serde(default)]
pub payload_index_io_read: u64,
#[serde(default)]
pub payload_index_io_write: u64,
#[serde(default)]
pub vector_io_read: u64,
#[serde(default)]
pub vector_io_write: u64,
}
impl HardwareUsage {
pub fn saturating_add(&self, other: &Self) -> Self {
Self {
cpu: self.cpu.saturating_add(other.cpu),
payload_io_read: self.payload_io_read.saturating_add(other.payload_io_read),
payload_io_write: self.payload_io_write.saturating_add(other.payload_io_write),
payload_index_io_read: self
.payload_index_io_read
.saturating_add(other.payload_index_io_read),
payload_index_io_write: self
.payload_index_io_write
.saturating_add(other.payload_index_io_write),
vector_io_read: self.vector_io_read.saturating_add(other.vector_io_read),
vector_io_write: self.vector_io_write.saturating_add(other.vector_io_write),
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ModelUsage {
#[serde(default)]
pub tokens: u64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct InferenceUsage {
#[serde(default)]
pub models: HashMap<String, ModelUsage>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ServerUsage {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hardware: Option<HardwareUsage>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inference: Option<InferenceUsage>,
}
impl ServerUsage {
pub fn from_json(value: &serde_json::Value) -> Option<Self> {
let obj = value.as_object()?;
let hardware = obj
.get("hardware")
.and_then(|h| serde_json::from_value(h.clone()).ok());
let inference = obj
.get("inference")
.and_then(|i| serde_json::from_value(i.clone()).ok());
if hardware.is_none() && inference.is_none() {
return None;
}
Some(Self {
hardware,
inference,
})
}
pub fn merge(&self, other: &Self) -> Self {
let hardware = match (&self.hardware, &other.hardware) {
(Some(a), Some(b)) => Some(a.saturating_add(b)),
(Some(a), None) => Some(a.clone()),
(None, Some(b)) => Some(b.clone()),
(None, None) => None,
};
let inference = match (&self.inference, &other.inference) {
(Some(a), Some(b)) => {
let mut models = a.models.clone();
for (name, usage) in &b.models {
models
.entry(name.clone())
.and_modify(|e: &mut ModelUsage| {
e.tokens = e.tokens.saturating_add(usage.tokens);
})
.or_insert_with(|| usage.clone());
}
Some(InferenceUsage { models })
}
(Some(a), None) => Some(a.clone()),
(None, Some(b)) => Some(b.clone()),
(None, None) => None,
};
Self {
hardware,
inference,
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ServerTelemetry {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub time_s: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage: Option<ServerUsage>,
}
impl ServerTelemetry {
pub fn from_envelope(value: &serde_json::Value) -> Self {
Self {
time_s: value.get("time").and_then(|t| t.as_f64()),
usage: value.get("usage").and_then(ServerUsage::from_json),
}
}
pub fn from_envelope_opt(value: &serde_json::Value) -> Option<Self> {
let tel = Self::from_envelope(value);
if tel.time_s.is_none() && tel.usage.is_none() {
None
} else {
Some(tel)
}
}
pub fn aggregate<'a>(
items: impl Iterator<Item = &'a ServerTelemetry>,
) -> Option<ServerTelemetry> {
let mut time_s: Option<f64> = None;
let mut usage: Option<ServerUsage> = None;
let mut any = false;
for item in items {
any = true;
if let Some(t) = item.time_s {
time_s = Some(time_s.unwrap_or(0.0) + t);
}
if let Some(u) = &item.usage {
usage = Some(match usage {
Some(acc) => acc.merge(u),
None => u.clone(),
});
}
}
if !any || (time_s.is_none() && usage.is_none()) {
return None;
}
Some(ServerTelemetry { time_s, usage })
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PhaseTimings {
pub parse_ms: f64,
pub prepare_plan_ms: f64,
pub dispatch_ms: f64,
pub decode_ms: f64,
pub total_ms: f64,
}