diff --git a/crates/openshell-supervisor-network/README.md b/crates/openshell-supervisor-network/README.md index dd8af76169..08b7f919da 100644 --- a/crates/openshell-supervisor-network/README.md +++ b/crates/openshell-supervisor-network/README.md @@ -94,3 +94,10 @@ filtering preserves raw HTTP bytes and borrows unchanged header blocks. It removes only protected receipt fields and their `Connection` or `Trailer` nominations, including folded continuations, without adding general response-header validation. + +The request scope pins the captured policy generation, selected endpoint and +first credential snapshot. Existing audit records gain only the selections +known at their emission; earlier records are not rewritten after a later lookup. +The provider revision fingerprints the complete credential environment, while +the installation ID distinguishes repairs at the same revision. Neither proves +that a credential was injected. diff --git a/crates/openshell-supervisor-network/src/l7/correlation.rs b/crates/openshell-supervisor-network/src/l7/correlation.rs index 1d4cfe36fa..c14ca8e62e 100644 --- a/crates/openshell-supervisor-network/src/l7/correlation.rs +++ b/crates/openshell-supervisor-network/src/l7/correlation.rs @@ -3,6 +3,8 @@ //! Request receipts and emission-time correlation without changing audit records. +mod resources; + use std::fmt; use std::future::Future; use std::sync::atomic::{AtomicU64, Ordering}; @@ -15,6 +17,7 @@ use crate::l7::provider::L7Request; use crate::l7::relay::L7EvalContext; pub use crate::l7::request_trace::RequestStage; use crate::l7::request_trace::RequestTrace; +use resources::RequestResources; tokio::task_local! { static CURRENT_REQUEST: Arc>>>; @@ -83,6 +86,14 @@ pub fn record_current_failure(outcome: HttpOutcome, reason: &'static str) { } } +pub fn record_current_provider_snapshot(revision: u64, installation_id: &str) { + if let Some(scope) = current_request().filter(|scope| scope.inspected) { + scope + .resources + .record_provider(revision, installation_id, &scope.span()); + } +} + fn enrich_request(event: &mut openshell_ocsf::BaseEventData) { let Some(scope) = current_request().filter(|scope| scope.inspected) else { return; @@ -97,6 +108,7 @@ fn enrich_request(event: &mut openshell_ocsf::BaseEventData) { .or_insert_with(|| event_kind.into()); fields.insert("request_sequence".into(), sequence.into()); } + scope.resources.enrich(event); } fn default_event_kind(class_uid: u32) -> &'static str { @@ -125,6 +137,7 @@ struct RequestScope { request_id: String, inspected: bool, sequence: AtomicU64, + resources: RequestResources, trace: Mutex>, } @@ -242,6 +255,7 @@ impl RequestCorrelation { request_id: uuid::Uuid::new_v4().to_string(), inspected: false, sequence: AtomicU64::new(1), + resources: RequestResources::default(), trace: Mutex::new(None), }) } @@ -262,6 +276,7 @@ impl RequestCorrelation { request_id, inspected: true, sequence: AtomicU64::new(1), + resources: RequestResources::default(), trace: Mutex::new(Some(trace)), }) } @@ -284,6 +299,22 @@ impl RequestCorrelation { &self.scope.request_id } + pub(crate) fn record_policy_generation(&self, generation: u64) { + if self.scope.inspected { + self.scope + .resources + .record_generation(generation, &self.scope.span()); + } + } + + pub(crate) fn record_selected_endpoint(&self, config: &crate::l7::L7EndpointConfig) { + if self.scope.inspected { + self.scope + .resources + .record_endpoint(config, &self.scope.span()); + } + } + pub(crate) fn capture_error(&self, error: miette::Report) -> miette::Report { if !self.scope.inspected || error.downcast_ref::().is_some() { return error; diff --git a/crates/openshell-supervisor-network/src/l7/correlation/resources.rs b/crates/openshell-supervisor-network/src/l7/correlation/resources.rs new file mode 100644 index 0000000000..6d03acd9ba --- /dev/null +++ b/crates/openshell-supervisor-network/src/l7/correlation/resources.rs @@ -0,0 +1,81 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use std::sync::OnceLock; + +use openshell_ocsf::BaseEventData; +use tracing::Span; + +use crate::l7::L7EndpointConfig; + +#[derive(Debug, Default)] +pub(super) struct RequestResources { + generation: OnceLock, + endpoint: OnceLock, + provider: OnceLock, +} + +#[derive(Debug)] +struct SelectedEndpoint { + policy_hash: String, + endpoint_id: String, +} + +#[derive(Debug)] +struct SelectedProvider { + revision: String, + installation_id: String, +} + +impl RequestResources { + pub(super) fn record_generation(&self, generation: u64, span: &Span) { + let generation = self.generation.get_or_init(|| generation.to_string()); + span.record("openshell.policy.runtime_generation", generation.as_str()); + } + + pub(super) fn record_endpoint(&self, config: &L7EndpointConfig, span: &Span) { + if config.policy_hash.is_empty() || config.endpoint_id.is_empty() { + return; + } + let selected = self.endpoint.get_or_init(|| SelectedEndpoint { + policy_hash: config.policy_hash.clone(), + endpoint_id: config.endpoint_id.clone(), + }); + span.record("openshell.policy.hash", selected.policy_hash.as_str()); + span.record("openshell.endpoint.id", selected.endpoint_id.as_str()); + } + + pub(super) fn record_provider(&self, revision: u64, installation_id: &str, span: &Span) { + let selected = self.provider.get_or_init(|| SelectedProvider { + revision: revision.to_string(), + installation_id: installation_id.to_owned(), + }); + span.record( + "openshell.provider.environment_revision", + selected.revision.as_str(), + ); + span.record( + "openshell.provider.credential_installation_id", + selected.installation_id.as_str(), + ); + } + + pub(super) fn enrich(&self, event: &mut BaseEventData) { + if let Some(generation) = self.generation.get() { + event.add_unmapped("policy_runtime_generation", generation.as_str()); + } + if let Some(selected) = self.endpoint.get() { + event.add_unmapped("policy_hash", selected.policy_hash.as_str()); + event.add_unmapped("endpoint_id", selected.endpoint_id.as_str()); + } + // Per-control records contain only selections already made when the + // record is emitted; a later credential lookup cannot rewrite them. + if let Some(selected) = self.provider.get() { + event.add_unmapped("provider_environment_revision", selected.revision.as_str()); + event.add_unmapped( + "provider_credential_installation_id", + selected.installation_id.as_str(), + ); + } + } +} diff --git a/crates/openshell-supervisor-network/src/l7/correlation/tests.rs b/crates/openshell-supervisor-network/src/l7/correlation/tests.rs index b7c7dca6cb..c4c70419d2 100644 --- a/crates/openshell-supervisor-network/src/l7/correlation/tests.rs +++ b/crates/openshell-supervisor-network/src/l7/correlation/tests.rs @@ -85,6 +85,164 @@ fn unused_request_scope_does_not_create_an_audit_record() { assert!(capture.json_events().is_empty()); } +fn resource_endpoint(policy_hash: &str, endpoint_id: &str) -> crate::l7::L7EndpointConfig { + crate::l7::parse_l7_config( + ®orus::Value::from_json_str( + &serde_json::json!({ + "protocol": "rest", "policy_hash": policy_hash, "endpoint_id": endpoint_id, + }) + .to_string(), + ) + .unwrap(), + ) + .unwrap() +} + +#[tokio::test] +async fn resource_snapshots_enrich_only_subsequent_records_without_trace_dependency() { + use openshell_core::provider_credentials::ProviderCredentialState; + use opentelemetry_sdk::trace::Sampler; + + let _lock = openshell_otel_test_support::tracing_test_lock().await; + for sampler in [None, Some(Sampler::AlwaysOn)] { + let sampled = sampler.is_some(); + let capture = RequestTracing::new(sampler); + let state = ProviderCredentialState::from_child_env_snapshot( + u64::MAX, + [("SECRET".into(), "RESOURCE-SECRET-SENTINEL".into())].into(), + ); + let before = state.snapshot(); + let after = scope_connection(async { + let mut ctx = L7EvalContext { + provider_credentials: Some(state.clone()), + ..context() + }; + let correlation = RequestCorrelation::new(&request(), &ctx); + correlation.record_policy_generation(u64::MAX); + correlation.record_selected_endpoint(&resource_endpoint("hash-a", "endpoint-a")); + correlation.emit(allowed()); + crate::l7::token_grant_injection::pin_live_credentials(&mut ctx).unwrap(); + correlation.emit(deny()); + state.install_child_env_snapshot(u64::MAX - 1, std::collections::HashMap::new()); + let after = state.snapshot(); + crate::l7::token_grant_injection::pin_live_credentials(&mut ctx).unwrap(); + correlation.record_policy_generation(2); + correlation.record_selected_endpoint(&resource_endpoint("hash-b", "endpoint-b")); + correlation.emit(allowed()); + correlation.record_outcome(HttpOutcome::Allowed); + drop(correlation); + + let next = RequestCorrelation::new(&request(), &ctx); + next.record_policy_generation(2); + next.record_selected_endpoint(&resource_endpoint("hash-b", "endpoint-b")); + crate::l7::token_grant_injection::pin_live_credentials(&mut ctx).unwrap(); + next.emit(allowed()); + next.record_outcome(HttpOutcome::Allowed); + after + }) + .with_subscriber(capture.subscriber()) + .await; + let events = capture.events.json_events(); + assert_eq!(events.len(), 4); + assert!(events[0]["unmapped"]["provider_environment_revision"].is_null()); + assert!(events[0]["unmapped"]["provider_credential_installation_id"].is_null()); + for (index, event) in events[..3].iter().enumerate() { + assert_eq!( + event["unmapped"]["policy_runtime_generation"], + u64::MAX.to_string() + ); + assert_eq!(event["unmapped"]["policy_hash"], "hash-a"); + assert_eq!(event["unmapped"]["endpoint_id"], "endpoint-a"); + assert_eq!(event["unmapped"]["request_sequence"], index + 1); + assert_eq!( + event["metadata"]["correlation_uid"], + events[0]["metadata"]["correlation_uid"] + ); + } + for event in &events[1..3] { + assert_eq!( + event["unmapped"]["provider_environment_revision"], + u64::MAX.to_string() + ); + assert_eq!( + event["unmapped"]["provider_credential_installation_id"], + before.installation_id + ); + } + assert_eq!(events[1]["action"], "Denied"); + assert_eq!(events[1]["unmapped"]["middleware_phase"], "response"); + assert_eq!(events[1]["unmapped"]["transformed"], true); + assert_eq!(events[3]["unmapped"]["policy_runtime_generation"], "2"); + assert_eq!(events[3]["unmapped"]["policy_hash"], "hash-b"); + assert_eq!(events[3]["unmapped"]["endpoint_id"], "endpoint-b"); + assert_eq!( + events[3]["unmapped"]["provider_environment_revision"], + (u64::MAX - 1).to_string() + ); + assert_eq!( + events[3]["unmapped"]["provider_credential_installation_id"], + after.installation_id + ); + assert_eq!(events[3]["unmapped"]["request_sequence"], 1); + assert_ne!( + events[0]["metadata"]["correlation_uid"], + events[3]["metadata"]["correlation_uid"] + ); + let spans = capture.spans(); + assert_eq!(spans.len(), usize::from(sampled) * 2); + if sampled { + let root = spans + .iter() + .find(|span| { + span_attribute(span, "openshell.request.id") + .unwrap() + .as_str() + == events[0]["metadata"]["correlation_uid"].as_str().unwrap() + }) + .unwrap(); + for (key, expected) in [ + ("openshell.policy.runtime_generation", u64::MAX.to_string()), + ("openshell.policy.hash", "hash-a".into()), + ("openshell.endpoint.id", "endpoint-a".into()), + ( + "openshell.provider.environment_revision", + u64::MAX.to_string(), + ), + ( + "openshell.provider.credential_installation_id", + before.installation_id.clone(), + ), + ] { + assert_eq!( + span_attribute(root, key).unwrap().as_str(), + expected, + "{key}" + ); + } + } + assert!(!format!("{events:?}{spans:?}").contains("RESOURCE-SECRET-SENTINEL")); + capture.shutdown(); + } +} + +#[tokio::test] +async fn uninspected_traffic_does_not_claim_resource_selections() { + let capture = OcsfCapture::default(); + let _subscriber = capture.install(); + scope_connection(async { + let correlation = RequestCorrelation::uninspected(); + correlation.record_policy_generation(4); + correlation.record_selected_endpoint(&resource_endpoint("hash", "endpoint")); + record_current_provider_snapshot(5, "installation"); + correlation.emit(allowed()); + }) + .await; + let events = capture.json_events(); + assert_eq!(events.len(), 1); + assert!(events[0]["metadata"]["correlation_uid"].is_null()); + assert!(events[0]["unmapped"].is_null()); +} + #[test] fn request_join_does_not_depend_on_export_and_never_creates_denial_spans() { use opentelemetry_sdk::trace::Sampler; diff --git a/crates/openshell-supervisor-network/src/l7/mod.rs b/crates/openshell-supervisor-network/src/l7/mod.rs index 0647b8b2fe..7631681bf0 100644 --- a/crates/openshell-supervisor-network/src/l7/mod.rs +++ b/crates/openshell-supervisor-network/src/l7/mod.rs @@ -2259,7 +2259,9 @@ mod tests { #[tokio::test] async fn non_mcp_endpoint_never_begins_an_observation() { - use openshell_core::endpoint_status::{EndpointConfigVersion, endpoint_status_channel}; + use openshell_core::endpoint_status::{ + EndpointConfigVersion, EndpointInventoryEntry, endpoint_status_channel, + }; let (sender, _receiver) = endpoint_status_channel(); sender @@ -2268,12 +2270,15 @@ mod tests { policy_hash: "policy".to_string(), provider_env_revision: 1, }, - Vec::new(), + vec![EndpointInventoryEntry { + endpoint_id: "endpoint:v1:not-mcp".to_string(), + uses_provider_credentials: false, + }], ) .await .expect("install MCP test configuration"); let value = regorus::Value::from_json_str( - r#"{"protocol":"rest","endpoint_id":"endpoint:v1:not-mcp"}"#, + r#"{"protocol":"rest","endpoint_id":"endpoint:v1:not-mcp","policy_hash":"policy"}"#, ) .expect("parse REST config JSON"); let config = parse_l7_config(&value).expect("parse REST config"); diff --git a/crates/openshell-supervisor-network/src/l7/relay.rs b/crates/openshell-supervisor-network/src/l7/relay.rs index 9725ef0ea5..d3b1be4c3e 100644 --- a/crates/openshell-supervisor-network/src/l7/relay.rs +++ b/crates/openshell-supervisor-network/src/l7/relay.rs @@ -1560,6 +1560,7 @@ where } }; let correlation = RequestCorrelation::new(&req, ctx); + correlation.record_policy_generation(engine.generation_guard().captured_generation()); let capture_error = |error| correlation.capture_error(error); if !request_authority_matches_endpoint(&req, ctx) { reject_request_authority_mismatch(client, ctx, &req.action, Some(&correlation)) @@ -1597,6 +1598,7 @@ where .map_err(&capture_error)?; return Ok(()); }; + correlation.record_selected_endpoint(config); let observer = EndpointObserver::begin_captured( ctx.endpoint_observation_tx.as_ref(), config, @@ -2586,6 +2588,8 @@ where } }; let correlation = RequestCorrelation::new(&req, ctx); + correlation.record_policy_generation(engine.generation_guard().captured_generation()); + correlation.record_selected_endpoint(config); let capture_error = |error| correlation.capture_error(error); if !request_authority_matches_endpoint(&req, ctx) { reject_request_authority_mismatch(client, ctx, &req.action, Some(&correlation)) @@ -3142,6 +3146,8 @@ where let req = parsed.request; let jsonrpc_info = parsed.info; let correlation = RequestCorrelation::new(&req, ctx); + correlation.record_policy_generation(engine.generation_guard().captured_generation()); + correlation.record_selected_endpoint(config); let capture_error = |error| correlation.capture_error(error); let observer = EndpointObserver::begin_captured( ctx.endpoint_observation_tx.as_ref(), @@ -3514,6 +3520,8 @@ where } }; let correlation = RequestCorrelation::new(&req, ctx); + correlation.record_policy_generation(engine.generation_guard().captured_generation()); + correlation.record_selected_endpoint(config); let capture_error = |error| correlation.capture_error(error); if !request_authority_matches_endpoint(&req, ctx) { @@ -4438,6 +4446,7 @@ where } else { RequestCorrelation::uninspected() }; + correlation.record_policy_generation(generation_guard.captured_generation()); let capture_error = |error| correlation.capture_error(error); let receipt = inspected.then_some(&correlation); if !request_authority_matches_endpoint(&req, ctx) { diff --git a/crates/openshell-supervisor-network/src/l7/relay/token_grant_ownership_tests.rs b/crates/openshell-supervisor-network/src/l7/relay/token_grant_ownership_tests.rs index d53b1e0abd..bfbba8666c 100644 --- a/crates/openshell-supervisor-network/src/l7/relay/token_grant_ownership_tests.rs +++ b/crates/openshell-supervisor-network/src/l7/relay/token_grant_ownership_tests.rs @@ -15,7 +15,7 @@ use crate::token_grant::test_support::{CacheAcquisition, CachedTokenGrantResolve use openshell_core::proto::{ ProviderCredentialTokenGrant, ProviderCredentialTokenGrantType, ProviderProfileCredential, }; -use openshell_core::provider_credentials::ProviderCredentialState; +use openshell_core::provider_credentials::{ProviderCredentialSnapshot, ProviderCredentialState}; use openshell_core::token_grant_failure::{ TokenGrantFailure, TokenGrantFailureKind, TokenGrantStage, }; @@ -1116,8 +1116,18 @@ async fn route_selected_keepalive_uses_live_grant_state_after_refresh() { keepalive_refresh(true).await; } -async fn refresh_during_grant(same_revision_repair: bool, route_selection: bool) { +struct RefreshVersions { + before: Arc, + after: Arc, + policy_generation: u64, +} + +async fn refresh_during_grant( + same_revision_repair: bool, + route_selection: bool, +) -> RefreshVersions { let fixture = refresh_fixture(route_selection); + let before = fixture.state.snapshot(); let old_key = fixture.grant_key("/a/**", "a"); fixture.resolver.hold_once.store(true, Ordering::SeqCst); let mut first = fixture.connect(); @@ -1136,6 +1146,7 @@ async fn refresh_during_grant(same_revision_repair: bool, route_selection: bool) } else { fixture.install(2, &[("/a/**", "a", "aud-new")]); } + let after = fixture.state.snapshot(); let new_key = fixture.grant_key("/a/**", "a"); assert_ne!(new_key, old_key, "replacement changes cache authority"); fixture.resolver.release.notify_one(); @@ -1154,6 +1165,81 @@ async fn refresh_during_grant(same_revision_repair: bool, route_selection: bool) fixture .resolver .assert_calls(&[(&old_key, "aud-old"), (&new_key, "aud-new")]); + RefreshVersions { + before, + after, + policy_generation: fixture.generation, + } +} + +#[tokio::test] +async fn request_resources_keep_the_provider_installation_selected_before_refresh() { + use super::correlation_dispatch_tests::capture_request_spans; + use crate::test_support::request_tracing::span_attribute; + + for same_revision_repair in [false, true] { + let evidence = + capture_request_spans(true, refresh_during_grant(same_revision_repair, true)).await; + let roots = evidence + .spans + .iter() + .filter(|span| span.name == "openshell.http.request") + .collect::>(); + assert_eq!(roots.len(), 2); + for snapshot in [&evidence.output.before, &evidence.output.after] { + let root = roots + .iter() + .find(|span| { + span_attribute(span, "openshell.provider.credential_installation_id") + .is_some_and(|value| value.as_str() == snapshot.installation_id) + }) + .expect("root retains its actual selected installation"); + assert_eq!( + span_attribute(root, "openshell.provider.environment_revision") + .unwrap() + .as_str(), + snapshot.revision.to_string(), + ); + assert_eq!( + span_attribute(root, "openshell.policy.runtime_generation") + .unwrap() + .as_str(), + evidence.output.policy_generation.to_string(), + ); + let receipt = span_attribute(root, "openshell.request.id") + .unwrap() + .as_str(); + let records = evidence + .events + .iter() + .filter(|event| { + event["metadata"]["correlation_uid"].as_str() == Some(receipt.as_ref()) + }) + .collect::>(); + assert!(!records.is_empty()); + assert!(records[0]["unmapped"]["provider_credential_installation_id"].is_null()); + let grant = records + .iter() + .find(|event| event["unmapped"]["http_event_kind"] == "token_grant") + .unwrap(); + assert_eq!( + grant["unmapped"]["provider_environment_revision"], + snapshot.revision.to_string() + ); + assert_eq!( + grant["unmapped"]["provider_credential_installation_id"], + snapshot.installation_id + ); + } + assert_ne!( + evidence.output.before.installation_id, + evidence.output.after.installation_id + ); + assert_eq!( + evidence.output.before.revision == evidence.output.after.revision, + same_revision_repair + ); + } } #[tokio::test] @@ -1214,6 +1300,64 @@ async fn route_selected_policy_reload_during_grant_closes_old_tunnel_and_reconne policy_reload_during_grant(true).await; } +#[tokio::test] +async fn completed_request_resources_survive_policy_reload_and_reconnect() { + use super::correlation_dispatch_tests::capture_request_spans; + use crate::test_support::request_tracing::span_attribute; + use crate::test_support::response_request_id; + + let evidence = capture_request_spans(true, async { + let mut fixture = refresh_fixture(true); + let old_generation = fixture.generation; + let mut first = fixture.connect(); + let response = first.exchange("GET", "/a/before", true).await; + assert!(response.starts_with("HTTP/1.1 204")); + let first_id = response_request_id(response.as_bytes()).to_owned(); + + fixture.reload_policy(); + assert!(first.observes_eof().await, "reload closes the idle tunnel"); + assert_eq!(first.finish().await.requests.len(), 1); + + let mut second = fixture.connect(); + let response = second.exchange("GET", "/a/after", true).await; + assert!(response.starts_with("HTTP/1.1 204")); + let second_id = response_request_id(response.as_bytes()).to_owned(); + assert_eq!(second.finish().await.requests.len(), 1); + assert_ne!(first_id, second_id); + [(first_id, old_generation), (second_id, fixture.generation)] + }) + .await; + for (receipt, generation) in evidence.output { + let generation = generation.to_string(); + let root = evidence + .spans + .iter() + .find(|span| { + span.name == "openshell.http.request" + && span_attribute(span, "openshell.request.id") + .is_some_and(|value| value.as_str() == receipt) + }) + .expect("each completed request has its own trace"); + assert_eq!( + span_attribute(root, "openshell.policy.runtime_generation") + .unwrap() + .as_str(), + generation + ); + let records = evidence + .events + .iter() + .filter(|event| event["metadata"]["correlation_uid"] == receipt) + .collect::>(); + assert!(!records.is_empty()); + assert!( + records + .iter() + .all(|event| { event["unmapped"]["policy_runtime_generation"] == generation }) + ); + } +} + fn assert_cache_acquisitions(resolver: &CachedTokenGrantResolver, expected: &[(&str, &str)]) { let expected = expected .iter() diff --git a/crates/openshell-supervisor-network/src/l7/request_trace.rs b/crates/openshell-supervisor-network/src/l7/request_trace.rs index 1d9c36a509..10af726fed 100644 --- a/crates/openshell-supervisor-network/src/l7/request_trace.rs +++ b/crates/openshell-supervisor-network/src/l7/request_trace.rs @@ -68,6 +68,11 @@ impl RequestTrace { openshell.request.outcome = tracing::field::Empty, openshell.request.failure_reason = tracing::field::Empty, http.response.status_code = tracing::field::Empty, + openshell.policy.runtime_generation = tracing::field::Empty, + openshell.policy.hash = tracing::field::Empty, + openshell.endpoint.id = tracing::field::Empty, + openshell.provider.environment_revision = tracing::field::Empty, + openshell.provider.credential_installation_id = tracing::field::Empty, otel.kind = "server", otel.status_code = tracing::field::Empty, ); diff --git a/crates/openshell-supervisor-network/src/l7/token_grant_injection.rs b/crates/openshell-supervisor-network/src/l7/token_grant_injection.rs index d24a77ec34..4407e5f838 100644 --- a/crates/openshell-supervisor-network/src/l7/token_grant_injection.rs +++ b/crates/openshell-supervisor-network/src/l7/token_grant_injection.rs @@ -177,6 +177,10 @@ pub fn pin_live_credentials(ctx: &mut L7EvalContext) -> Option St // Every inspected protocol must bind grant reporting to the // policy selected before credential acquisition. ep["policy_hash"] = policy_hash.clone().into(); - if is_mcp_protocol(&e.protocol) { + if matches!( + PolicyL7Protocol::parse(&e.protocol), + Some( + PolicyL7Protocol::Rest + | PolicyL7Protocol::Graphql + | PolicyL7Protocol::JsonRpc + | PolicyL7Protocol::Mcp + | PolicyL7Protocol::Websocket + ) + ) { // Derive endpoint identity from the policy endpoint while // it is still available. Request handling carries this // opaque value through exact path selection and never @@ -3493,7 +3501,10 @@ mod tests { // this metadata independently and compare all remaining configuration. expected["policy_hash"] = deterministic_policy_hash(canonical_policy).into(); assert_eq!(proto_config["policy_hash"], expected["policy_hash"]); - if is_mcp_protocol(&endpoint.protocol) { + if matches!( + endpoint.protocol.as_str(), + "rest" | "graphql" | "json-rpc" | "mcp" | "websocket" + ) { expected["endpoint_id"] = openshell_core::endpoint_status::endpoint_id(endpoint).into(); assert_eq!(proto_config["endpoint_id"], expected["endpoint_id"]); } else { @@ -8140,6 +8151,32 @@ network_policies: assert_eq!(l7.policy_hash, expected_hash); } + #[test] + fn request_endpoint_identity_is_projected_for_http_inspected_protocols_only() { + for (protocol, inspected) in [ + ("rest", true), + ("graphql", true), + ("json-rpc", true), + ("MCP", true), + ("websocket", true), + ("sql", false), + ("tcp", false), + ] { + let mut policy = defaultable_mcp_proto(None); + let endpoint = &mut policy.network_policies.get_mut("mcp").unwrap().endpoints[0]; + endpoint.protocol = protocol.into(); + let expected = openshell_core::endpoint_status::endpoint_id(endpoint); + let projected: serde_json::Value = + serde_json::from_str(&proto_to_opa_data_json(&policy, 0)).unwrap(); + let endpoint = &projected["network_policies"]["mcp"]["endpoints"][0]; + if inspected { + assert_eq!(endpoint["endpoint_id"], expected, "{protocol}"); + } else { + assert!(endpoint.get("endpoint_id").is_none(), "{protocol}"); + } + } + } + #[tokio::test] async fn mixed_case_mcp_policy_keeps_endpoint_observation_identity() { use openshell_core::endpoint_status::{ diff --git a/crates/openshell-supervisor-network/src/proxy.rs b/crates/openshell-supervisor-network/src/proxy.rs index be255a423b..39ae4758ca 100644 --- a/crates/openshell-supervisor-network/src/proxy.rs +++ b/crates/openshell-supervisor-network/src/proxy.rs @@ -5989,6 +5989,7 @@ async fn handle_forward_proxy_inner( } else { crate::l7::correlation::RequestCorrelation::uninspected() }; + correlation.record_policy_generation(forward_generation_guard.captured_generation()); let request_correlation = inspected.then_some(&correlation); let receipt_id = request_correlation.map(crate::l7::correlation::RequestCorrelation::request_id); @@ -6100,6 +6101,7 @@ async fn handle_forward_proxy_inner( .await?; return Ok(()); }; + correlation.record_selected_endpoint(&l7_config.config); endpoint_observer = crate::l7::EndpointObserver::begin_captured( l7_ctx.endpoint_observation_tx.as_ref(), &l7_config.config, diff --git a/docs/observability/ocsf-json-export.mdx b/docs/observability/ocsf-json-export.mdx index 875bc04812..1dae06ccbd 100644 --- a/docs/observability/ocsf-json-export.mdx +++ b/docs/observability/ocsf-json-export.mdx @@ -375,6 +375,23 @@ collection. To count policy outcomes, group by `metadata.correlation_uid` and select the actual policy or firewall control record. Do not count every HTTP Activity or `decision` record as another request. +Request-scoped records also carry the selections known when they were emitted: + +| `unmapped` field | Meaning | +|---|---| +| `policy_runtime_generation` | Policy generation captured for the request. | +| `policy_hash` | Canonical hash of the selected policy. | +| `endpoint_id` | Selected endpoint identity. | +| `provider_environment_revision` | Fingerprint of the complete pinned credential environment, not an individual provider revision. | +| `provider_credential_installation_id` | Identifies the pinned credential installation, including repairs at the same revision. | + +Generation and revision values are decimal strings to preserve their full +precision. Fields remain absent until selection occurs, so an early policy +record can lack provider metadata present on a later credential record. These +fields do not prove that a credential was injected or a request was delivered. +The request span records the same selections under `openshell.policy.*`, +`openshell.endpoint.id` and `openshell.provider.*`. + Errors that end an inspected request retain that request's ID. A policy reload records the active request before closing it; an idle connection has no request ID. The `101` upgrade handoff record shares the HTTP handshake ID. Later