appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use serde::Serialize;
use std::path::Path;
use std::time::Duration;

#[derive(Clone, Debug, Serialize)]
pub(crate) struct RuntimeStatus {
    pub api_url: String,
    pub api_ready: bool,
    pub web_url: String,
    pub web_ready: bool,
    pub metrics: Option<RuntimeMetrics>,
}

#[derive(Clone, Debug, Serialize)]
pub(crate) struct RuntimeMetrics {
    pub requests: u64,
    pub server_errors: u64,
    pub average_latency_ms: Option<f64>,
    pub jobs_in_flight: u64,
    pub job_retries: u64,
}

pub(crate) fn runtime_status(project: &Path) -> RuntimeStatus {
    let environment = crate::environment::ProjectEnvironment::load(project).unwrap_or_default();
    let api_port = environment
        .get("APPSTRUCT_API_PORT")
        .and_then(|value| value.parse::<u16>().ok())
        .unwrap_or(3000);
    let web_port = environment
        .get("APPSTRUCT_WEB_PORT")
        .and_then(|value| value.parse::<u16>().ok())
        .unwrap_or(5173);
    let api_url = format!("http://127.0.0.1:{api_port}");
    let web_url = format!("http://127.0.0.1:{web_port}");
    let Ok(client) = reqwest::blocking::Client::builder()
        .timeout(Duration::from_millis(500))
        .build()
    else {
        return RuntimeStatus {
            api_url,
            api_ready: false,
            web_url,
            web_ready: false,
            metrics: None,
        };
    };
    let api_ready = client
        .get(format!("{api_url}/health/ready"))
        .send()
        .is_ok_and(|response| response.status().is_success());
    let web_ready = client
        .get(&web_url)
        .send()
        .is_ok_and(|response| response.status().is_success());
    let metrics = api_ready
        .then(|| client.get(format!("{api_url}/metrics")).send().ok())
        .flatten()
        .filter(|response| response.status().is_success())
        .and_then(|response| response.text().ok())
        .map(|source| parse_metrics(&source));
    RuntimeStatus {
        api_url,
        api_ready,
        web_url,
        web_ready,
        metrics,
    }
}

fn parse_metrics(source: &str) -> RuntimeMetrics {
    let request_metric = "appstruct_http_request_duration_seconds_count";
    let request_samples = metric_value_sum(source, request_metric, None);
    let requests = metric_sum(source, request_metric, None);
    let server_errors = metric_sum(source, request_metric, Some("status_class=\"5xx\""));
    let duration = metric_value_sum(source, "appstruct_http_request_duration_seconds_sum", None);
    RuntimeMetrics {
        requests,
        server_errors,
        average_latency_ms: (request_samples > 0.0).then_some(duration * 1_000.0 / request_samples),
        jobs_in_flight: metric_sum(source, "appstruct_jobs_in_flight", None),
        job_retries: metric_sum(source, "appstruct_job_retries_total", None),
    }
}

fn metric_sum(source: &str, name: &str, required_label: Option<&str>) -> u64 {
    source
        .lines()
        .filter(|line| line.starts_with(name))
        .filter(|line| required_label.is_none_or(|label| line.contains(label)))
        .filter_map(|line| line.split_whitespace().last()?.parse::<u64>().ok())
        .fold(0, u64::saturating_add)
}

fn metric_value_sum(source: &str, name: &str, required_label: Option<&str>) -> f64 {
    source
        .lines()
        .filter(|line| line.starts_with(name))
        .filter(|line| required_label.is_none_or(|label| line.contains(label)))
        .filter_map(|line| line.split_whitespace().last()?.parse::<f64>().ok())
        .sum()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn prometheus_metrics_are_summarized_without_label_cardinality() {
        let metrics = parse_metrics(
            "appstruct_http_request_duration_seconds_count{route=\"/a\",status_class=\"2xx\"} 3\n\
             appstruct_http_request_duration_seconds_sum{route=\"/a\",status_class=\"2xx\"} 0.12\n\
             appstruct_http_request_duration_seconds_count{route=\"/b\",status_class=\"5xx\"} 1\n\
             appstruct_http_request_duration_seconds_sum{route=\"/b\",status_class=\"5xx\"} 0.08\n\
             appstruct_jobs_in_flight 2\n\
             appstruct_job_retries_total 4\n",
        );
        assert_eq!(metrics.requests, 4);
        assert_eq!(metrics.server_errors, 1);
        assert_eq!(metrics.average_latency_ms, Some(50.0));
        assert_eq!(metrics.jobs_in_flight, 2);
        assert_eq!(metrics.job_retries, 4);
    }
}