cencori 1.4.0

Official Rust SDK for Cencori - AI Infrastructure for Production
Documentation
/// Module for fetching Cencori usage metrics.
use std::collections::HashMap;
use std::sync::Arc;

use crate::client::{parse_response, InnerClient};
use crate::error::CencoriError;
use crate::types::{
    Breakdown, CostMetrics, LatencyMetrics, MetricsResponse, RequestMetrics, TokenMetrics,
};

/// Module for fetching Cencori usage metrics.
#[derive(Debug, Clone)]
pub struct MetricsModule {
    inner: Arc<InnerClient>,
}

impl MetricsModule {
    pub(crate) fn new(inner: Arc<InnerClient>) -> Self {
        Self { inner }
    }

    /// Get metrics for a specific period.
    ///
    /// # Arguments
    ///
    /// * `period` - Time period (e.g., "24h", "7d", "30d").
    pub fn get(&self, period: &str) -> Result<MetricsResponse, CencoriError> {
        let path = format!("/v1/metrics?period={period}");
        let url = self.inner.url(&path);
        let response = self
            .inner
            .blocking_client
            .get(&url)
            .send()
            .map_err(CencoriError::Http)?;

        let status = response.status();
        let body = response.text().map_err(CencoriError::Http)?;
        let data = parse_response(status, &body)?;

        let parse_breakdown = |obj: &serde_json::Map<_, _>| -> HashMap<String, Breakdown> {
            obj.iter()
                .map(|(k, v)| {
                    (
                        k.clone(),
                        Breakdown {
                            requests: v["requests"].as_u64().unwrap_or(0),
                            cost_usd: v["cost_usd"].as_f64().unwrap_or(0.0),
                        },
                    )
                })
                .collect()
        };

        Ok(MetricsResponse {
            period: data["period"].as_str().unwrap_or_default().to_string(),
            start_date: data["start_date"].as_str().unwrap_or_default().to_string(),
            end_date: data["end_date"].as_str().unwrap_or_default().to_string(),
            requests: RequestMetrics {
                total: data["requests"]["total"].as_u64().unwrap_or(0),
                success: data["requests"]["success"].as_u64().unwrap_or(0),
                error: data["requests"]["error"].as_u64().unwrap_or(0),
                filtered: data["requests"]["filtered"].as_u64().unwrap_or(0),
                success_rate: data["requests"]["success_rate"].as_f64().unwrap_or(0.0),
            },
            cost: CostMetrics {
                total_usd: data["cost"]["total_usd"].as_f64().unwrap_or(0.0),
                average_per_request_usd: data["cost"]["average_per_request_usd"]
                    .as_f64()
                    .unwrap_or(0.0),
            },
            tokens: TokenMetrics {
                prompt: data["tokens"]["prompt"].as_u64().unwrap_or(0),
                completion: data["tokens"]["completion"].as_u64().unwrap_or(0),
                total: data["tokens"]["total"].as_u64().unwrap_or(0),
            },
            latency: LatencyMetrics {
                avg_ms: data["latency"]["avg_ms"].as_u64().unwrap_or(0),
                p50_ms: data["latency"]["p50_ms"].as_u64().unwrap_or(0),
                p90_ms: data["latency"]["p90_ms"].as_u64().unwrap_or(0),
                p99_ms: data["latency"]["p99_ms"].as_u64().unwrap_or(0),
            },
            providers: data["providers"]
                .as_object()
                .map(parse_breakdown)
                .unwrap_or_default(),
            models: data["models"]
                .as_object()
                .map(parse_breakdown)
                .unwrap_or_default(),
        })
    }
}