feat(usage): enrich audit metadata and detail views

2026-10-10 19:29:50 +08:00 · 2026-07-17 19:20:16 +08:00
parent 0be380243b
commit 664c063a06
79 changed files with 6968 additions and 1294 deletions
@@ -733,6 +733,110 @@ async fn admin_monitoring_trace_request_exposes_failed_candidate_upstream_respon
    assert!(extra.get("provider_response").is_none());
 }

+#[tokio::test]
+async fn admin_monitoring_trace_request_prefers_ref_backed_usage_response_body() {
+    let mut candidate = sample_candidate(
+        "cand-used",
+        "request-ref-body",
+        0,
+        RequestCandidateStatus::Failed,
+        Some(101),
+        Some(33),
+        Some(400),
+    );
+    candidate.extra_data = Some(json!({
+        "upstream_response": {
+            "status_code": 400,
+            "headers": {
+                "content-type": "text/event-stream",
+                "x-request-id": "stale-request-like-body"
+            },
+            "body": {
+                "model": "gpt-5.6-sol",
+                "input": [{"role": "user", "content": "request prompt"}]
+            }
+        }
+    }));
+
+    let request_candidates = Arc::new(InMemoryRequestCandidateRepository::seed(vec![candidate]));
+    let provider_catalog = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![sample_provider()],
+        vec![sample_endpoint()],
+        vec![sample_key()],
+    ));
+    let mut usage = sample_usage(
+        "request-ref-body",
+        "provider-1",
+        "OpenAI",
+        0,
+        0.0,
+        "failed",
+        Some(400),
+        100,
+    );
+    usage.candidate_id = Some("cand-used".to_string());
+    usage.response_headers = Some(json!({
+        "content-type": "application/json",
+        "x-request-id": "req_usage-cyber-risk-demo"
+    }));
+    usage.response_body = Some(json!({
+        "error": {
+            "type": "invalid_request",
+            "message": "This content was flagged for possible cybersecurity risk.",
+            "code": 400
+        }
+    }));
+    usage.response_body_state = Some(UsageBodyCaptureState::Reference);
+    let usage_repository = Arc::new(InMemoryUsageReadRepository::seed_with_detached_bodies(
+        vec![usage],
+    ));
+    let data_state =
+        crate::data::GatewayDataState::with_request_candidate_and_usage_repository_for_tests(
+            request_candidates,
+            usage_repository,
+        )
+        .with_provider_catalog_reader(provider_catalog);
+    let state = AppState::new()
+        .expect("state should build")
+        .with_data_state_for_tests(data_state);
+    let context = request_context(
+        http::Method::GET,
+        "/api/admin/monitoring/trace/request-ref-body",
+    );
+
+    let response = local_monitoring_response(&state, &context)
+        .await
+        .expect("handler should not error")
+        .expect("route should be handled locally");
+
+    assert_eq!(response.status(), http::StatusCode::OK);
+    let body = to_bytes(response.into_body(), usize::MAX)
+        .await
+        .expect("body should read");
+    let payload: serde_json::Value = serde_json::from_slice(&body).expect("json body should parse");
+    let upstream_response = &payload["candidates"][0]["extra_data"]["upstream_response"];
+    assert_eq!(
+        upstream_response["headers"],
+        json!({
+            "content-type": "application/json",
+            "x-request-id": "req_usage-cyber-risk-demo"
+        })
+    );
+    assert_eq!(
+        upstream_response["body"]["error"],
+        json!({
+            "type": "invalid_request",
+            "message": "This content was flagged for possible cybersecurity risk.",
+            "code": 400
+        })
+    );
+    assert!(upstream_response["body"].get("input").is_none());
+    assert_eq!(
+        upstream_response["body_ref"],
+        json!("usage://request/request-ref-body/response_body")
+    );
+}
+
 #[tokio::test]
 async fn admin_monitoring_trace_request_decodes_connect_json_response_body_refs() {
    let mut candidate = sample_candidate(
@@ -30,6 +30,25 @@ struct ResolvedAdminMonitoringTrace {
    usage: Option<StoredRequestUsageAudit>,
 }

+async fn hydrate_admin_monitoring_trace_response_body(
+    state: &AdminAppState<'_>,
+    mut usage: StoredRequestUsageAudit,
+) -> Result<StoredRequestUsageAudit, GatewayError> {
+    let is_error_node = !usage.status.eq_ignore_ascii_case("completed")
+        || usage
+            .status_code
+            .is_some_and(|status| !(200..300).contains(&status));
+    let response_body_ref = if is_error_node && usage.response_body.is_none() {
+        usage.response_body_ref.clone()
+    } else {
+        None
+    };
+    if let Some(body_ref) = response_body_ref.as_deref() {
+        usage.response_body = state.resolve_request_usage_body_ref(body_ref).await?;
+    }
+    Ok(usage)
+}
+
 pub(super) async fn build_admin_monitoring_trace_request_response(
    state: &AdminAppState<'_>,
    request_context: &AdminRequestContext<'_>,
@@ -92,6 +111,10 @@ async fn resolve_admin_monitoring_trace(
            .read_request_usage_audit_shallow(request_id)
            .await
            .map_err(|err| GatewayError::Internal(err.to_string()))?;
+        let usage = match usage {
+            Some(usage) => Some(hydrate_admin_monitoring_trace_response_body(state, usage).await?),
+            None => None,
+        };
        return Ok(Some(ResolvedAdminMonitoringTrace { trace, usage }));
    }

@@ -102,9 +125,10 @@ async fn resolve_admin_monitoring_trace(
        .await
        .map_err(|err| GatewayError::Internal(err.to_string()))?
    {
-        usage_candidates.push(usage);
+        usage_candidates.push(hydrate_admin_monitoring_trace_response_body(state, usage).await?);
    }
    if let Some(usage) = state.find_request_usage_by_id(request_id).await? {
+        let usage = hydrate_admin_monitoring_trace_response_body(state, usage).await?;
        if !usage_candidates.iter().any(|item| item.id == usage.id) {
            usage_candidates.push(usage);
        }