refactor: rename linux_agent to system_agent and update related cache handling

Author: racicLuka

metrics-cache/src/handlers/ingest.rs

@@ -7,6 +7,7 @@ use std::time::Instant;
 use crate::AppState;
 use crate::auth::kubernetes::TokenValidator;
 use crate::ingest::MetricsFetcherIngestion;
+use crate::ingest::SystemAgentOutput;
 use crate::ingest::kubelet_stats::StatsSummary;
 
 pub async fn kubelet_stats_summary(
@@ -25,22 +26,54 @@ pub async fn kubelet_stats_summary(
     Json("ok".to_string())
 }
 
-/// Store the raw check_mk_agent output for a node as-is, keyed by node
-/// name. No parsing/validation is done here or by the caller. Kept as
-/// [`Bytes`] rather than [`String`] since agent plugins are not guaranteed to
-/// produce valid UTF-8.
-pub async fn linux_agent(
+/// Store the raw output of a machine-level agent (currently only Linux's
+/// `check_mk_agent`) for a node as-is, keyed by node name. No
+/// parsing/validation is done here or by the caller. Kept as [`Bytes`]
+/// rather than [`String`] since agent plugins are not guaranteed to produce
+/// valid UTF-8.
+pub async fn system_agent(
     State(state): State<AppState<impl TokenValidator>>,
     Path(node_name): Path<String>,
     body: Bytes,
 ) -> Json<String> {
     let ingestion = MetricsFetcherIngestion {
         received_at: Instant::now(),
-        payload: body,
+        payload: SystemAgentOutput(body),
     };
     state
-        .linux_agent_cache
+        .system_agent_cache
         .insert(node_name, Arc::new(ingestion))
         .await;
     Json("ok".to_string())
 }
+
+#[cfg(test)]
+mod tests {
+    use axum::extract::{Path, State};
+
+    use super::*;
+    use crate::state::tests::test_app_state;
+
+    /// Exercises the handler directly (no router, no auth middleware) — this
+    /// is about whether the handler does what's expected of it, not whether
+    /// the route is wired up correctly; that's covered in `handlers::tests`.
+    #[tokio::test]
+    async fn system_agent_populates_cache_and_returns_ok() {
+        let state = test_app_state();
+        let cache = state.system_agent_cache.clone();
+
+        let Json(resp) = system_agent(
+            State(state),
+            Path("node-1".to_string()),
+            Bytes::from_static(b"<<<check_mk>>>\nVersion: 2.5.0\n"),
+        )
+        .await;
+
+        assert_eq!(resp, "ok");
+        cache.run_pending_tasks().await;
+        assert_eq!(
+            cache.get("node-1").await.map(|v| v.payload.0.clone()),
+            Some(Bytes::from_static(b"<<<check_mk>>>\nVersion: 2.5.0\n"))
+        );
+    }
+}

metrics-cache/src/handlers/mod.rs

@@ -36,7 +36,7 @@ pub fn ingest_app<V: TokenValidator>(state: AppState<V>) -> Router {
             "/kubelet_stats_summary",
             post(ingest::kubelet_stats_summary),
         )
-        .route("/linux_agent/{node_name}", post(ingest::linux_agent))
+        .route("/system_agent/{node_name}", post(ingest::system_agent))
         .route_layer(middleware::from_fn_with_state(
             state.clone(),
             auth::kubernetes::authenticate,
@@ -50,68 +50,26 @@ pub fn ingest_app<V: TokenValidator>(state: AppState<V>) -> Router {
 
 #[cfg(test)]
 mod tests {
-    use axum::body::{Body, Bytes};
+    use axum::body::Body;
     use axum::http::{Request, StatusCode};
-    use k8s_openapi::api::authentication::v1::{TokenReview, TokenReviewStatus, UserInfo};
     use tower::ServiceExt;
 
     use super::*;
-    use crate::state::tests::{MockValidator, test_app_state, test_app_state_with_validator};
-
-    fn authenticated_review(username: &str) -> TokenReview {
-        TokenReview {
-            status: Some(TokenReviewStatus {
-                authenticated: Some(true),
-                user: Some(UserInfo {
-                    username: Some(username.to_string()),
-                    ..Default::default()
-                }),
-                ..Default::default()
-            }),
-            ..Default::default()
-        }
-    }
-
-    #[tokio::test]
-    async fn linux_agent_ingest_populates_cache_and_returns_ok() {
-        let state = test_app_state_with_validator(MockValidator {
-            response: Ok(authenticated_review(
-                "system:serviceaccount:test-ns:test-writer",
-            )),
-        });
-        let cache = state.linux_agent_cache.clone();
-        let app = ingest_app(state);
-
-        let resp = app
-            .oneshot(
-                Request::builder()
-                    .method("POST")
-                    .uri("/ingest/linux_agent/node-1")
-                    .header("Authorization", "Bearer test-token")
-                    .body(Body::from("<<<check_mk>>>\nVersion: 2.5.0\n"))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        assert_eq!(resp.status(), StatusCode::OK);
-        cache.run_pending_tasks().await;
-        assert_eq!(
-            cache.get("node-1").await.map(|v| v.payload.clone()),
-            Some(Bytes::from_static(b"<<<check_mk>>>\nVersion: 2.5.0\n"))
-        );
-    }
+    use crate::state::tests::test_app_state;
 
+    /// Sanity check that the ingest route is actually wired up behind the
+    /// kubernetes-token middleware; handler-level behavior is covered in
+    /// `handlers::ingest::tests`.
     #[tokio::test]
-    async fn linux_agent_ingest_requires_auth() {
+    async fn system_agent_ingest_requires_auth() {
         let state = test_app_state();
         let app = ingest_app(state);
 
         let resp = app
             .oneshot(
                 Request::builder()
                     .method("POST")
-                    .uri("/ingest/linux_agent/node-1")
+                    .uri("/ingest/system_agent/node-1")
                     .body(Body::from("<<<check_mk>>>\n"))
                     .unwrap(),
             )

metrics-cache/src/ingest/mod.rs

@@ -1,3 +1,4 @@
+use axum::body::Bytes;
 use std::time::Instant;
 
 pub mod kubelet_stats;
@@ -13,3 +14,11 @@ pub struct MetricsFetcherIngestion<T> {
     pub received_at: Instant,
     pub payload: T,
 }
+
+/// Raw output from a machine-level agent (currently only Linux's
+/// `check_mk_agent`, but named generically since a Windows agent could push
+/// here too some day). A distinct type rather than a bare [`Bytes`], so the
+/// cache's shape stays unambiguous if another `Bytes`-based payload is ever
+/// added.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SystemAgentOutput(pub Bytes);

metrics-cache/src/state.rs

@@ -1,4 +1,3 @@
-use axum::body::Bytes;
 use kube::Client;
 use moka::future::Cache;
 use std::sync::Arc;
@@ -10,6 +9,7 @@ use crate::cli_args::CliArgs;
 use crate::error::Result;
 use crate::host_settings::{AlwaysEmitted, AnnotationKeyPattern, HostSettings};
 use crate::ingest::MetricsFetcherIngestion;
+use crate::ingest::SystemAgentOutput;
 use crate::ingest::kubelet_stats::StatsSummary;
 use crate::ingest::reflectors::Stores;
 
@@ -23,7 +23,7 @@ pub struct AppState<V: TokenValidator> {
     pub reader_allowlist: Vec<String>,
     pub writer_allowlist: Vec<String>,
     pub kubelet_stats_summary_cache: Cache<String, Arc<MetricsFetcherIngestion<StatsSummary>>>,
-    pub linux_agent_cache: Cache<String, Arc<MetricsFetcherIngestion<Bytes>>>,
+    pub system_agent_cache: Cache<String, Arc<MetricsFetcherIngestion<SystemAgentOutput>>>,
     pub host_settings: Arc<HostSettings>,
 }
 
@@ -49,7 +49,7 @@ impl AppState<Client> {
             kubelet_stats_summary_cache: Cache::builder()
                 .max_capacity(MAX_SUPPORTED_KUBERNETES_NODES)
                 .build(),
-            linux_agent_cache: Cache::builder()
+            system_agent_cache: Cache::builder()
                 .max_capacity(MAX_SUPPORTED_KUBERNETES_NODES)
                 .build(),
             host_settings: host_settings.into(),
@@ -106,7 +106,7 @@ pub mod tests {
                 .time_to_live(Duration::from_secs(120))
                 .max_capacity(10000)
                 .build(),
-            linux_agent_cache: Cache::builder()
+            system_agent_cache: Cache::builder()
                 .time_to_live(Duration::from_secs(120))
                 .max_capacity(10000)
                 .build(),

metrics-fetcher/src/payload.rs

@@ -14,7 +14,7 @@ impl Payload {
     fn metrics_cache_endpoint(&self) -> String {
         match self {
             Self::KubeletStatsSummary(_) => "/kubelet_stats_summary".to_string(),
-            Self::CheckmkLinuxAgent { node_name, .. } => format!("/linux_agent/{node_name}"),
+            Self::CheckmkLinuxAgent { node_name, .. } => format!("/system_agent/{node_name}"),
         }
     }