otelite 0.1.97

Otelite: OTLP receiver, dashboard, and CLI for local OpenTelemetry observability
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! Agent rollup command: per-harness (opencode/codex/claude) sessions, cost,
//! tokens, tool calls and retries over a time window.

use crate::commands::usage::{fetch_pricing, parse_time_range};
use crate::error::{Error, Result};
use clap::Args;
use comfy_table::{presets::UTF8_FULL, ContentArrangement, Table};
use otelite_core::api::AgentRollupResponse;
use otelite_storage::StorageBackend;
use std::sync::Arc;

/// Show a per-harness rollup: sessions, cost, tokens, tool calls, retries
#[derive(Debug, Args)]
pub struct AgentsCommand {
    /// Time range to query (e.g., "1h", "24h", "7d", "30d")
    #[arg(long, default_value = "24h", value_parser = crate::commands::usage::validate_since)]
    pub since: String,
}

impl AgentsCommand {
    pub async fn execute(
        &self,
        storage: Arc<dyn StorageBackend>,
        format: crate::config::OutputFormat,
    ) -> Result<()> {
        let (start_time, end_time) = parse_time_range(&self.since)?;

        // Series buckets: one hour (the web endpoint accepts its own).
        let rollups = storage
            .query_agent_rollup(Some(start_time), Some(end_time), 3600)
            .await
            .map_err(|e| Error::ApiError(format!("Failed to query agent rollup: {}", e)))?;

        let pricing_db = fetch_pricing().await;
        let mut agents: Vec<_> = rollups.into_iter().map(|r| r.enrich(&pricing_db)).collect();
        agents.sort_by(|a, b| {
            b.cost_usd
                .unwrap_or(0.0)
                .partial_cmp(&a.cost_usd.unwrap_or(0.0))
                .unwrap_or(std::cmp::Ordering::Equal)
                .then_with(|| a.agent.cmp(&b.agent))
        });
        let response = AgentRollupResponse {
            agents,
            filters_applied: Vec::new(),
        };

        use crate::config::OutputFormat;
        match format {
            OutputFormat::Json | OutputFormat::JsonCompact => {
                let json = if matches!(format, OutputFormat::JsonCompact) {
                    serde_json::to_string(&response)
                } else {
                    serde_json::to_string_pretty(&response)
                };
                println!(
                    "{}",
                    json.map_err(|e| Error::ApiError(format!("JSON serialization failed: {}", e)))?
                );
            },
            OutputFormat::Pretty => display_agents(&response),
        }
        Ok(())
    }
}

fn fmt_tokens(n: u64) -> String {
    if n >= 1_000_000 {
        format!("{:.2}M", n as f64 / 1_000_000.0)
    } else if n >= 1_000 {
        format!("{:.1}k", n as f64 / 1_000.0)
    } else {
        n.to_string()
    }
}

fn fmt_cost(c: Option<f64>, source: Option<&str>) -> String {
    match c {
        Some(v) if v > 0.0 => match source {
            Some("actual") => format!("${:.2} (actual)", v),
            _ => format!("${:.2}", v),
        },
        Some(_) => "$0.00".to_string(),
        None => "—".to_string(),
    }
}

fn display_agents(response: &AgentRollupResponse) {
    if response.agents.is_empty() {
        println!("\nNo agent activity in the window.\n");
        return;
    }

    println!("\nAgents:\n");
    let mut table = Table::new();
    table
        .load_preset(UTF8_FULL)
        .set_content_arrangement(ContentArrangement::Dynamic)
        .set_header(vec![
            "agent",
            "sessions",
            "cost",
            "tokens",
            "tool calls",
            "retries",
        ]);
    for a in &response.agents {
        table.add_row(vec![
            a.agent.clone(),
            a.sessions.to_string(),
            fmt_cost(a.cost_usd, a.cost_source.as_deref()),
            fmt_tokens(a.tokens.total()),
            fmt_tokens(a.tool_calls),
            a.retries.map(fmt_tokens).unwrap_or_else(|| "—".to_string()),
        ]);
    }
    println!("{}", table);
    println!();
}