use anyhow::Result;
use askama::Template;
use axum::Extension;
use axum::body::Bytes;
use axum::extract::RawQuery;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use super::auth::Viewer;
use crate::args::{MetricsArgs, MetricsWindow};
use crate::config::UserConfig;
use crate::logs::metrics::fleet::{self, FailedCommand, Fleet};
use crate::logs::metrics::{Bucket, Class, Ending, Stopped, Timeline, Trends};
const FILTERS: [&str; 10] = fleet::VIEW_KEYS;
const STOPPED_AT: &str = "stopped_at";
const CATEGORY: &str = "category";
const FAILED_ON: &str = "failed_on";
const FAILED_KIND: &str = "failed_kind";
const FAILED_ACCOUNT: &str = "failed_account";
const MACHINE: &str = "machine";
const FLEET: &str = "fleet";
struct Machines {
chosen: Option<String>,
fleet: bool,
local: String,
others: Vec<String>,
}
impl Machines {
fn pair(&self) -> Option<(&str, &str)> {
self.chosen
.as_deref()
.filter(|_| self.fleet)
.map(|chosen| (MACHINE, chosen))
}
fn is(&self, name: &str) -> bool {
self.chosen.as_deref() == Some(name)
}
}
#[derive(Template)]
#[template(path = "console/metrics.html")]
struct MetricsPage {
page: super::PageContext,
trends: Trends,
error: Option<String>,
form: Form,
kinds: [&'static str; 9],
windows: [(&'static str, MetricsWindow); 4],
classes: [Class; 4],
view: Vec<(String, String)>,
machines: Machines,
}
impl MetricsPage {
fn link(&self, path: &str, replaced: &[&str], added: &[(&str, &str)]) -> String {
let mut url = reqwest::Url::parse("http://localhost").expect("fixed URL");
url.set_path(path);
url.query_pairs_mut()
.extend_pairs(
self.view
.iter()
.filter(|(key, _)| !replaced.contains(&key.as_str())),
)
.extend_pairs(added);
format!("{}?{}", url.path(), url.query().unwrap_or_default())
}
fn row_history(&self, row: &Stopped) -> String {
let category = [(CATEGORY, row.ending.category())];
match &row.stopped_at {
Some(stage) => self.link("/history", &[], &[(STOPPED_AT, stage), category[0]]),
None => self.link("/history", &[], &category),
}
}
fn bucket_history(&self, bucket: &Bucket) -> String {
let day = bucket.bucket.to_string();
let mut added = vec![(FAILED_ON, day.as_str()), (FAILED_KIND, bucket.kind)];
if let Some(account) = &bucket.account {
added.push((FAILED_ACCOUNT, account));
}
self.link("/history", &[], &added)
}
fn version_slice(&self, version: &str) -> String {
let mut added = vec![("version", version)];
added.extend(self.machines.pair());
self.link("/metrics", &["version"], &added)
}
fn details(&self, selector: &str) -> String {
crate::logs::status::inspect::url("/peek", selector, None)
}
}
#[derive(Template)]
#[template(path = "console/metrics_fleet.html")]
struct FleetPage {
page: super::PageContext,
fleet: Fleet,
error: Option<String>,
form: Form,
kinds: [&'static str; 9],
windows: [(&'static str, MetricsWindow); 4],
classes: [Class; 4],
machines: Machines,
cli: String,
}
impl FleetPage {
fn age(&self, at: &chrono::DateTime<chrono::Utc>) -> String {
let seconds = (chrono::Utc::now() - *at).num_seconds().max(0);
let (count, unit) = match seconds {
0..60 => return "just now".into(),
60..3_600 => (seconds / 60, "minute"),
3_600..86_400 => (seconds / 3_600, "hour"),
_ => (seconds / 86_400, "day"),
};
format!("{count} {unit}{} ago", if count == 1 { "" } else { "s" })
}
fn unopened(&self, failed: &FailedCommand) -> &'static str {
let reported = self.fleet.machines.iter().any(|machine| {
machine.name == failed.machine && machine.status == fleet::Status::Reported
});
if reported { "reported" } else { "cached" }
}
fn details(&self, failed: &FailedCommand) -> Option<String> {
let machine = self
.fleet
.machines
.iter()
.find(|machine| machine.name == failed.machine)?;
let route = crate::logs::status::inspect::url("/peek", &failed.command.selector, None);
if machine.local {
Some(route)
} else if machine.status == fleet::Status::Ok {
Some(crate::logs::status::inspect::machine_url(
&route,
&machine.name,
))
} else {
None
}
}
}
#[derive(Default)]
struct Form {
window: String,
grain: String,
from: String,
through: String,
repo: Vec<String>,
kind: Vec<String>,
harness: Vec<String>,
model: Vec<String>,
version: Vec<String>,
account: Vec<String>,
}
impl Form {
fn of(asked: &MetricsArgs) -> Self {
let fields = |values: &[String]| {
if values.is_empty() {
vec![String::new()]
} else {
values.to_vec()
}
};
let date =
|date: Option<chrono::NaiveDate>| date.map(|d| d.to_string()).unwrap_or_default();
Self {
window: asked
.window
.map(|window| window.name().to_owned())
.unwrap_or_default(),
grain: asked
.grain
.map(|grain| grain.name().to_owned())
.unwrap_or_default(),
from: date(asked.from),
through: date(asked.through),
repo: fields(&asked.repositories),
kind: fields(&asked.kinds),
harness: fields(&asked.harnesses),
model: fields(&asked.models),
version: fields(&asked.versions),
account: fields(&asked.accounts),
}
}
}
fn pairs(query: &Option<String>, keys: &[&str]) -> Result<Vec<(String, String)>> {
Ok(reqwest::Url::parse(&format!(
"http://localhost/?{}",
query.as_deref().unwrap_or_default()
))?
.query_pairs()
.filter(|(key, value)| !value.is_empty() && keys.contains(&key.as_ref()))
.map(|(key, value)| (key.into_owned(), value.into_owned()))
.collect())
}
pub(super) fn drilldown(query: &Option<String>) -> Result<Vec<(String, String)>> {
let mut keys = FILTERS.to_vec();
keys.extend([STOPPED_AT, CATEGORY, FAILED_ON, FAILED_KIND, FAILED_ACCOUNT]);
pairs(query, &keys)
}
pub(super) fn chosen(config: &UserConfig, query: &Option<String>) -> Result<Option<Vec<String>>> {
let drill = pairs(
query,
&[STOPPED_AT, CATEGORY, FAILED_ON, FAILED_KIND, FAILED_ACCOUNT],
)?;
let value = |key: &str| {
drill
.iter()
.find(|(name, _)| name == key)
.map(|(_, value)| value.as_str())
};
if value(CATEGORY).is_none() && value(FAILED_ON).is_none() {
return Ok(None);
}
let view = pairs(query, &FILTERS)?;
let view = reqwest::Url::parse_with_params("http://localhost/", &view)?;
let trends =
crate::logs::metrics::trends(config, &arguments(&view.query().map(str::to_owned))?)?;
if let Some(category) = value(CATEGORY) {
let ending = Ending::named(category)
.ok_or_else(|| anyhow::anyhow!("unknown failure category: {category}"))?;
return Ok(Some(
trends
.where_runs_failed
.rows
.iter()
.filter(|row| {
row.ending == ending && row.stopped_at.as_deref() == value(STOPPED_AT)
})
.flat_map(Stopped::selectors)
.cloned()
.collect(),
));
}
Ok(Some(
trends
.outcomes
.iter()
.filter(|bucket| {
value(FAILED_ON) == Some(bucket.bucket.to_string().as_str())
&& value(FAILED_KIND) == Some(bucket.kind)
&& value(FAILED_ACCOUNT) == bucket.account.as_deref()
})
.flat_map(|bucket| bucket.failed_commands.iter().cloned())
.collect(),
))
}
fn arguments(query: &Option<String>) -> Result<MetricsArgs> {
let mut arguments = vec!["metrics".to_owned(), "--json".to_owned()];
if let Some(query) = query {
for (key, value) in
reqwest::Url::parse(&format!("http://localhost/?{query}"))?.query_pairs()
{
if value.is_empty() {
continue;
}
match key.as_ref() {
"command" => arguments.push(value.into_owned()),
key if FILTERS.contains(&key) => {
arguments.push(format!("--{key}"));
arguments.push(value.into_owned());
}
_ => anyhow::bail!("unknown metrics argument: {key}"),
}
}
}
let crate::args::Command::Metrics(asked) = crate::args::parse(&arguments)? else {
unreachable!("fixed metrics command")
};
Ok(asked)
}
fn without_machine(query: &Option<String>) -> Result<Option<String>> {
let Some(query) = query else {
return Ok(None);
};
let url = reqwest::Url::parse(&format!("http://localhost/?{query}"))?;
Ok(Some(serde_urlencoded::to_string(
url.query_pairs()
.filter(|(key, _)| key != MACHINE)
.collect::<Vec<_>>(),
)?))
}
pub(super) async fn show(
Extension(viewer): Extension<Viewer>,
Extension(format): Extension<super::api::Format>,
RawQuery(query): RawQuery,
) -> Response {
if format == super::api::Format::Json
&& pairs(&query, &[MACHINE, FLEET]).map_or(true, |pairs| !pairs.is_empty())
{
return super::api::error(
StatusCode::BAD_REQUEST,
"Fleet metrics are an explicit client view; call each owning machine's API directly",
);
}
let machine = super::query_value(&query, MACHINE);
super::api::read(format, move || {
let config = UserConfig::load()?;
let query = without_machine(&query)?;
let (asked, error) = match arguments(&query) {
Ok(asked) => (asked, None),
Err(error) if format == super::api::Format::Html => {
(MetricsArgs::default(), Some(format!("{error:#}")))
}
Err(error) => return Err(error),
};
if asked.command.is_some() {
return format.render(crate::logs::metrics::read(&config, &asked)?, |value| {
Ok(format!(
"<pre>{}</pre>",
super::filters::escaped(&serde_json::to_string_pretty(&value)?)
))
});
}
let local = super::fleet_control::local_name(&config);
let capture = (format == super::api::Format::Html)
.then(|| fleet::Capture::new(&config, viewer.fleet_person()));
let fleet = capture.as_ref().is_some_and(fleet::Capture::default_view);
let machines = Machines {
chosen: match machine.as_str() {
"" if fleet => None,
"" => Some(local.clone()),
chosen => Some(chosen.to_owned()),
},
fleet,
others: capture
.as_ref()
.map(fleet::Capture::others)
.unwrap_or_default(),
local,
};
if !machines.is(&machines.local) {
let mut asked = asked;
asked.machine = machines.chosen.clone();
let mut cli = vec!["metrics".to_owned()];
match &asked.machine {
Some(name) => cli.extend(["--machine".to_owned(), name.clone()]),
None => cli.push("--fleet".to_owned()),
}
cli.extend(
pairs(&query, &FILTERS)?
.into_iter()
.flat_map(|(key, value)| [format!("--{key}"), value]),
);
cli.push("--json".into());
let fleet = capture
.as_ref()
.expect("HTML Fleet view has a capture")
.load(&asked)?;
return format.render(fleet, |fleet| {
Ok(FleetPage {
page: super::PageContext::new(&config, &viewer.scopes),
fleet,
error,
form: Form::of(&asked),
kinds: crate::logs::metrics::COUNTED.map(crate::logs::display_name),
windows: MetricsWindow::NAMES,
classes: Class::ENDED,
machines,
cli: crate::args::shell_command(cli),
}
.render()?)
});
}
let view = if error.is_none() {
pairs(&query, &FILTERS)?
} else {
Vec::new()
};
format.render(crate::logs::metrics::trends(&config, &asked)?, |trends| {
Ok(MetricsPage {
page: super::PageContext::new(&config, &viewer.scopes),
trends,
error,
form: Form::of(&asked),
kinds: crate::logs::metrics::COUNTED.map(crate::logs::display_name),
windows: MetricsWindow::NAMES,
classes: Class::ENDED,
view,
machines,
}
.render()?)
})
})
.await
}
pub(super) const REPORT_LIMIT: usize = 4 * 1024 * 1024;
pub(super) async fn receive(Extension(viewer): Extension<Viewer>, body: Bytes) -> Response {
let super::identity::Identity::Token { holder, .. } = viewer.identity else {
return super::api::error(StatusCode::FORBIDDEN, "Missing scope: report");
};
let report = serde_json::from_slice::<serde_json::Value>(&body)
.and_then(serde_json::from_value::<fleet::MetricsReport>);
let report = match report {
Ok(report) => report,
Err(error) => {
return super::api::error(
StatusCode::UNPROCESSABLE_ENTITY,
format!("invalid metrics report: {error}"),
);
}
};
let result = tokio::task::spawn_blocking(move || -> Result<_> {
let config = UserConfig::load()?;
let now = chrono::Utc::now();
let local = super::fleet_control::local_name(&config);
report.receive(&config.logs_dir, &holder, &local, now)?;
Ok(serde_json::json!({"machine": holder, "pushed_at": now}))
})
.await;
let error = match result {
Ok(Ok(receipt)) => return axum::Json(receipt).into_response(),
Ok(Err(error)) => match error.downcast_ref::<fleet::Refusal>() {
Some(refusal @ fleet::Refusal::Mismatch) => {
return super::api::error(StatusCode::FORBIDDEN, refusal);
}
Some(refusal) => {
return super::api::error(StatusCode::UNPROCESSABLE_ENTITY, refusal);
}
None => error,
},
Err(error) => error.into(),
};
eprintln!("thirdshift Console: metrics report not saved: {error:?}");
super::api::error(
StatusCode::INTERNAL_SERVER_ERROR,
"Could not save the metrics report.",
)
}