vllora 0.1.23

AI gateway for managing and routing LLM requests - Govern, Secure, and Optimize your AI Traffic.
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
120
121
122
123
124
125
126
127
128
129

use crate::CliError;
use clap::Subcommand;
use uuid::Uuid;
use vllora_core::mcp::server::VlloraMcp;
use vllora_core::metadata::pool::DbPool;
use vllora_core::metadata::services::project::ProjectServiceImpl;
use vllora_core::metadata::services::trace::TraceServiceImpl as MetadataTraceServiceImpl;
use vllora_core::metadata::DatabaseServiceTrait;
use vllora_core::types::metadata::services::project::ProjectService;

mod call_info;
mod list;
mod overview;
mod run_info;

#[derive(Subcommand)]
pub enum TracesCommands {
    /// Search/list traces
    List {
        /// Limit number of results
        #[arg(long, default_value_t = 20)]
        limit: i64,
        /// Offset for pagination
        #[arg(long, default_value_t = 0)]
        offset: i64,
        /// Filter by run ID
        #[arg(long)]
        run_id: Option<String>,
        /// Filter by thread ID
        #[arg(long)]
        thread_id: Option<String>,
        /// Filter by operation name (run, agent, task, tools, openai, anthropic, bedrock, gemini, model_call)
        #[arg(long)]
        operation_name: Option<String>,
        /// Text search query
        #[arg(long)]
        text: Option<String>,
        /// Filter traces from last N minutes
        #[arg(long)]
        last_n_minutes: Option<i64>,
        /// Sort by field (default: start_time)
        #[arg(long, default_value = "start_time")]
        sort_by: String,
        /// Sort order (asc or desc)
        #[arg(long, default_value = "desc")]
        sort_order: String,
        /// Output format (table or json)
        #[arg(long, default_value = "table")]
        output: String,
    },
    /// Get detailed LLM call information for a span
    CallInfo {
        /// Span ID
        #[arg(long)]
        span_id: String,
        /// Output format (table or json)
        #[arg(long, default_value = "table")]
        output: String,
    },
    /// Get overview of a run and its spans
    RunInfo {
        /// Run ID
        #[arg(long)]
        run_id: String,
        /// Output format (table or json)
        #[arg(long, default_value = "table")]
        output: String,
    },
    /// Get aggregated stats for recent LLM and tool calls
    Overview {
        /// Number of minutes in the past to include
        #[arg(long)]
        last_n_minutes: i64,
        /// Output format (table or json)
        #[arg(long, default_value = "table")]
        output: String,
    },
}

pub async fn handle_traces(db_pool: DbPool, cmd: TracesCommands) -> Result<(), CliError> {
    let project_service = ProjectServiceImpl::new(db_pool.clone());
    let project_slug = project_service
        .get_default(Uuid::nil())
        .ok()
        .map(|p| p.slug);
    // Create VlloraMcp instance with the trace service
    let trace_service = MetadataTraceServiceImpl::init(db_pool.clone());
    let vllora_mcp = VlloraMcp::new(trace_service, project_slug);

    match cmd {
        TracesCommands::List {
            limit,
            offset,
            run_id,
            thread_id,
            operation_name,
            text,
            last_n_minutes,
            sort_by,
            sort_order,
            output,
        } => {
            list::handle_list(
                &vllora_mcp,
                limit,
                offset,
                run_id,
                thread_id,
                operation_name,
                text,
                last_n_minutes,
                sort_by,
                sort_order,
                output,
            )
            .await
        }
        TracesCommands::CallInfo { span_id, output } => {
            call_info::handle_call_info(&vllora_mcp, span_id, output).await
        }
        TracesCommands::RunInfo { run_id, output } => {
            run_info::handle_run_info(&vllora_mcp, run_id, output).await
        }
        TracesCommands::Overview {
            last_n_minutes,
            output,
        } => overview::handle_overview(&vllora_mcp, last_n_minutes, output).await,
    }
}