Files
rust-discovery/crates/server/src/monitoring.rs
T
2026-11-14 00:52:40 +01:00

199 lines
7.3 KiB
Rust

use axum::{
Json,
extract::{Path, State},
http::{HeaderMap, StatusCode},
};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use sqlx::Row;
use uuid::Uuid;
pub async fn health(
State(s): State<crate::State>,
h: HeaderMap,
Path(t): Path<Uuid>,
) -> Result<Json<Value>, StatusCode> {
let Json(devices) = crate::api::devices(State(s), h, Path(t)).await?;
Ok(Json(
json!({"items":devices["items"],"next_cursor":null,"completeness":devices["completeness"],"truncated":devices["truncated"],"as_of":Utc::now(),"health":"unknown","source_id":"stored_agent_observations"}),
))
}
#[derive(Deserialize, Serialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct LogQuery {
pub tenant_id: Uuid,
pub asset_id: Uuid,
pub unit: String,
pub since: DateTime<Utc>,
pub until: DateTime<Utc>,
pub max_lines: u32,
pub live: bool,
pub idempotency_key: Option<String>,
}
pub async fn query(
s: &crate::State,
p: &crate::auth::Principal,
i: LogQuery,
) -> Result<Value, crate::jobs::Error> {
crate::jobs::scope(p, i.tenant_id, true)?;
let action = rmm_domain::jobs::Action::QueryLogs {
unit: i.unit.clone(),
since: i.since,
until: i.until,
max_lines: i.max_lines,
};
if !action.validate() {
return Err(crate::jobs::Error(
StatusCode::BAD_REQUEST,
"VALIDATION_ERROR",
));
}
if i.live {
let request_hash = rmm_domain::jobs::hash(&serde_json::to_vec(&i)?);
let mut dedup = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?;
let key = i
.idempotency_key
.as_ref()
.filter(|k| !k.is_empty() && k.len() <= 128)
.ok_or(crate::jobs::Error(
StatusCode::BAD_REQUEST,
"VALIDATION_ERROR",
))?;
if let Some(row)=sqlx::query("SELECT request_hash,plan_id FROM live_query_requests WHERE principal=$1 AND idempotency_key=$2").bind(&p.name).bind(key).fetch_optional(&mut *dedup).await?{
if row.get::<String,_>("request_hash")!=request_hash{return Err(crate::jobs::Error(StatusCode::CONFLICT,"IDEMPOTENCY_CONFLICT"))}
let plan=row.get("plan_id");let key=key.clone();dedup.commit().await?;
return crate::jobs::submit(s,p,i.tenant_id,plan,crate::jobs::Submit{idempotency_key:key}).await;
}
dedup.commit().await?;
let key = i.idempotency_key.ok_or(crate::jobs::Error(
StatusCode::BAD_REQUEST,
"VALIDATION_ERROR",
))?;
let plan = crate::jobs::plan(
s,
p,
i.tenant_id,
crate::jobs::PlanInput {
targets: crate::jobs::Targets {
asset_ids: vec![i.asset_id],
},
action,
script_variants: vec![],
execution_identity: "agent_service".into(),
schedule: crate::jobs::Schedule {
not_before: Utc::now(),
start_before: Utc::now() + chrono::Duration::hours(1),
},
max_runtime_seconds: 30,
max_output_bytes: 262144,
rollout: crate::jobs::Rollout {
max_parallel: 1,
halt_after_failures: 1,
},
reason: format!("Requested live logs for {}", i.unit),
artifact_ids: vec![],
},
)
.await?;
let id = plan["plan_id"]
.as_str()
.and_then(|v| Uuid::parse_str(v).ok())
.ok_or(crate::jobs::Error(
StatusCode::INTERNAL_SERVER_ERROR,
"VALIDATION_ERROR",
))?;
let mut dedup = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?;
sqlx::query(
"INSERT INTO live_query_requests VALUES($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING",
)
.bind(i.tenant_id)
.bind(&p.name)
.bind(&key)
.bind(&request_hash)
.bind(id)
.execute(&mut *dedup)
.await?;
let canonical=sqlx::query("SELECT request_hash,plan_id FROM live_query_requests WHERE principal=$1 AND idempotency_key=$2").bind(&p.name).bind(&key).fetch_one(&mut *dedup).await?;
if canonical.get::<String, _>("request_hash") != request_hash {
return Err(crate::jobs::Error(
StatusCode::CONFLICT,
"IDEMPOTENCY_CONFLICT",
));
}
let id = canonical.get("plan_id");
dedup.commit().await?;
return crate::jobs::submit(
s,
p,
i.tenant_id,
id,
crate::jobs::Submit {
idempotency_key: key,
},
)
.await;
}
let mut tx = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?;
crate::permissions::require_principal(&mut tx, p, "logs:read").await?;
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM assets WHERE asset_id=$1)")
.bind(i.asset_id)
.fetch_one(&mut *tx)
.await?;
if !exists {
return Err(crate::jobs::Error(StatusCode::NOT_FOUND, "NOT_FOUND"));
}
let rows=sqlx::query("SELECT j.job_id,j.payload,j.result FROM jobs j WHERE j.asset_id=$1 AND j.state='succeeded' AND j.result IS NOT NULL ORDER BY job_id LIMIT 100").bind(i.asset_id).fetch_all(&mut *tx).await?;
let mut items = Vec::new();
let mut size = 0;
let mut lines = 0usize;
let mut truncated = false;
for r in rows {
let payload: rmm_domain::jobs::JobPayload =
serde_json::from_slice(&r.get::<Vec<u8>, _>("payload"))?;
if let rmm_domain::jobs::Action::QueryLogs {
unit, since, until, ..
} = payload.action
&& unit == i.unit
&& since >= i.since
&& until <= i.until
{
let result: Value = r.get("result");
let len = result.to_string().len();
let stdout = result.get("stdout").and_then(Value::as_array);
let count = stdout
.map(|bytes| {
bytes.iter().filter(|v| v.as_u64() == Some(10)).count()
+ usize::from(bytes.last().is_some_and(|v| v.as_u64() != Some(10)))
})
.unwrap_or(0);
if size + len > 262144 || lines + count > i.max_lines as usize {
truncated = true;
break;
}
size += len;
lines += count;
items.push(json!({"job_id":r.get::<Uuid,_>("job_id"),"source_id":unit,"observed_from":since,"observed_until":until,"result":result}));
}
}
tx.commit().await?;
Ok(
json!({"state":"ready","items":items,"next_cursor":null,"completeness":"partial","truncated":truncated,"as_of":Utc::now(),"source_id":"authorized_job_results"}),
)
}
pub async fn logs(
State(s): State<crate::State>,
h: HeaderMap,
Path(t): Path<Uuid>,
Json(i): Json<LogQuery>,
) -> Result<Json<Value>, crate::jobs::Error> {
let p = s
.auth
.principal(&s, &h, i.live)
.await
.map_err(|s| crate::jobs::Error(s, "FORBIDDEN"))?;
if t != i.tenant_id {
return Err(crate::jobs::Error(StatusCode::NOT_FOUND, "NOT_FOUND"));
}
Ok(Json(query(&s, &p, i).await?))
}