Files
crank/apps/admin-api/tests/request_context_parent.rs
T
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

354 lines
12 KiB
Rust

use admin_api::request_context::{TRACE_ID_HEADER, apply_request_context};
use axum::{
Router,
body::Body,
http::Request,
response::Response,
routing::{MethodRouter, get},
};
use opentelemetry::{
Context,
trace::{SpanId, TraceContextExt, TracerProvider as _},
};
use opentelemetry_sdk::{
error::OTelSdkResult,
trace::{SdkTracerProvider, SpanData, SpanExporter},
};
use std::sync::{Arc, Mutex};
use tower::ServiceExt;
use tracing::Instrument;
use tracing_subscriber::layer::SubscriberExt;
const REMOTE_TRACE_ID: &str = "0af7651916cd43dd8448eb211c80319c";
const REMOTE_PARENT_SPAN_ID: &str = "b7ad6b7169203331";
#[derive(Clone, Debug, Default)]
struct RecordingSpanExporter {
spans: Arc<Mutex<Vec<SpanData>>>,
}
impl RecordingSpanExporter {
fn finished(&self) -> Vec<SpanData> {
self.spans
.lock()
.expect("recording exporter lock must be available")
.clone()
}
fn named(&self, name: &str) -> Option<SpanData> {
self.finished()
.into_iter()
.find(|span| span.name.as_ref() == name)
}
}
impl SpanExporter for RecordingSpanExporter {
async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
self.spans
.lock()
.expect("recording exporter lock must be available")
.extend(batch);
Ok(())
}
}
struct TracedRequest {
app: Router,
provider: SdkTracerProvider,
exporter: RecordingSpanExporter,
_dispatch_guard: tracing::dispatcher::DefaultGuard,
}
impl TracedRequest {
fn new(route: MethodRouter) -> Self {
let exporter = RecordingSpanExporter::default();
let provider = SdkTracerProvider::builder()
.with_simple_exporter(exporter.clone())
.build();
let tracer = provider.tracer("admin-request-context-parent-test");
let subscriber =
tracing_subscriber::registry().with(tracing_opentelemetry::layer().with_tracer(tracer));
let dispatch = tracing::Dispatch::new(subscriber);
let dispatch_guard = tracing::dispatcher::set_default(&dispatch);
let app = Router::new()
.route("/probe", route)
.layer(axum::middleware::from_fn(apply_request_context));
Self {
app,
provider,
exporter,
_dispatch_guard: dispatch_guard,
}
}
async fn send(&self, headers: &[(&str, &str)]) -> Response {
let mut request = Request::builder().uri("/probe");
for (name, value) in headers {
request = request.header(*name, *value);
}
self.app
.clone()
.oneshot(request.body(Body::empty()).unwrap())
.await
.expect("probe request must succeed")
}
fn response_trace_id(response: &Response) -> String {
response.headers()[TRACE_ID_HEADER]
.to_str()
.expect("response trace id header must be visible ascii")
.to_owned()
}
fn shutdown(self) {
let Self {
provider,
_dispatch_guard,
..
} = self;
let _ = provider.shutdown();
}
}
async fn probe() -> &'static str {
"ok"
}
async fn stage_probe() -> &'static str {
let span = crank_trace::Stage::AuthResolve.span();
async {
crank_trace::StageOutcome::Success.record(&span);
}
.instrument(span.clone())
.await;
"ok"
}
fn assert_request_span_is_exported(request: &TracedRequest, expected_trace_id: &str) {
let span = request.exporter.named("http.request").unwrap_or_else(|| {
panic!(
"inbound http.request span must be recorded and exported; exported spans: {:?}",
request
.exporter
.finished()
.iter()
.map(|span| span.name.to_string())
.collect::<Vec<_>>()
)
});
assert!(
span.span_context.is_valid(),
"inbound http.request span must carry a valid span context"
);
assert!(
span.span_context.is_sampled(),
"inbound http.request span must be sampled"
);
assert_eq!(
span.span_context.trace_id().to_string(),
expected_trace_id,
"exported request span must carry the trace id reported to the client"
);
}
#[tokio::test(flavor = "current_thread")]
async fn preserves_remote_trace_id_with_an_active_tracer_and_no_global_propagator() {
let provider = SdkTracerProvider::builder().build();
let tracer = provider.tracer("admin-request-context-parent-test");
let subscriber =
tracing_subscriber::registry().with(tracing_opentelemetry::layer().with_tracer(tracer));
let dispatch = tracing::Dispatch::new(subscriber);
let _dispatch_guard = tracing::dispatcher::set_default(&dispatch);
let app = Router::new()
.route("/probe", get(probe))
.layer(axum::middleware::from_fn(apply_request_context));
let response = app
.oneshot(
Request::builder()
.uri("/probe")
.header(
"traceparent",
"00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01",
)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(
response.headers()[TRACE_ID_HEADER],
"0af7651916cd43dd8448eb211c80319c"
);
provider.shutdown().unwrap();
}
#[tokio::test(flavor = "current_thread")]
async fn exports_the_inbound_request_span_when_the_ambient_otel_context_is_suppressed() {
let request = TracedRequest::new(get(probe));
// A suppressed ambient OTel context is exactly what the intermittent production gate failure
// shows: a contextual `crank::trace` span inherits the suppression, is created non-recording
// and therefore never reaches the exporter.
let _suppressed = Context::enter_telemetry_suppressed_scope();
let response = request.send(&[]).await;
assert_eq!(response.status(), 200);
let trace_id = TracedRequest::response_trace_id(&response);
assert_request_span_is_exported(&request, &trace_id);
request.shutdown();
}
#[tokio::test(flavor = "current_thread")]
async fn exports_the_inbound_request_span_when_an_unrelated_span_is_the_ambient_context() {
let request = TracedRequest::new(get(probe));
let ambient_tracer = request.provider.tracer("unrelated-ambient");
let ambient_span = opentelemetry::trace::Tracer::start(&ambient_tracer, "unrelated.stage");
let ambient_trace_id = opentelemetry::trace::Span::span_context(&ambient_span)
.trace_id()
.to_string();
let _ambient_guard = Context::current_with_span(ambient_span).attach();
let response = request.send(&[]).await;
assert_eq!(response.status(), 200);
let trace_id = TracedRequest::response_trace_id(&response);
assert_request_span_is_exported(&request, &trace_id);
let span = request.exporter.named("http.request").unwrap();
assert_ne!(
span.span_context.trace_id().to_string(),
ambient_trace_id,
"an inbound request without traceparent must not join an unrelated ambient trace"
);
assert!(
span.parent_span_id == SpanId::INVALID,
"an inbound request without traceparent must be a root span"
);
request.shutdown();
}
#[tokio::test(flavor = "current_thread")]
async fn preserves_remote_parent_identity_and_sampling_decision() {
let sampled = TracedRequest::new(get(probe));
let response = sampled
.send(&[(
"traceparent",
"00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01",
)])
.await;
assert_eq!(TracedRequest::response_trace_id(&response), REMOTE_TRACE_ID);
let span = sampled
.exporter
.named("http.request")
.expect("sampled remote parent must be exported");
assert_eq!(span.span_context.trace_id().to_string(), REMOTE_TRACE_ID);
assert_eq!(
span.parent_span_id.to_string(),
REMOTE_PARENT_SPAN_ID,
"remote traceparent parent span must be preserved"
);
assert!(span.span_context.is_sampled());
sampled.shutdown();
let unsampled = TracedRequest::new(get(probe));
let response = unsampled
.send(&[(
"traceparent",
"00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-00",
)])
.await;
assert_eq!(TracedRequest::response_trace_id(&response), REMOTE_TRACE_ID);
assert!(
unsampled.exporter.finished().is_empty(),
"an unsampled remote parent must not be exported"
);
unsampled.shutdown();
}
#[tokio::test(flavor = "current_thread")]
async fn generates_a_sampled_root_span_for_absent_or_invalid_traceparent() {
let absent = TracedRequest::new(get(probe));
let response = absent.send(&[]).await;
let trace_id = TracedRequest::response_trace_id(&response);
assert_request_span_is_exported(&absent, &trace_id);
assert!(
absent
.exporter
.named("http.request")
.unwrap()
.parent_span_id
== SpanId::INVALID,
"an absent traceparent must produce a root request span"
);
absent.shutdown();
let invalid = TracedRequest::new(get(probe));
let response = invalid
.send(&[("traceparent", "canary-invalid-traceparent")])
.await;
let trace_id = TracedRequest::response_trace_id(&response);
assert_ne!(trace_id, "canary-invalid-traceparent");
assert_request_span_is_exported(&invalid, &trace_id);
invalid.shutdown();
}
#[tokio::test(flavor = "current_thread")]
async fn keeps_stage_child_spans_linked_to_the_inbound_request_span() {
let request = TracedRequest::new(get(stage_probe));
let response = request.send(&[]).await;
assert_eq!(response.status(), 200);
let trace_id = TracedRequest::response_trace_id(&response);
assert_request_span_is_exported(&request, &trace_id);
let request_span = request.exporter.named("http.request").unwrap();
let stage_span = request
.exporter
.named("auth.resolve")
.expect("stage spans must stay recorded and exported");
assert_eq!(
stage_span.span_context.trace_id().to_string(),
request_span.span_context.trace_id().to_string(),
"stage spans must stay in the request trace"
);
assert_eq!(
stage_span.parent_span_id.to_string(),
request_span.span_context.span_id().to_string(),
"stage spans must stay children of the inbound request span"
);
request.shutdown();
}
#[tokio::test(flavor = "current_thread")]
async fn keeps_stage_child_spans_linked_when_the_ambient_otel_context_is_suppressed() {
let request = TracedRequest::new(get(stage_probe));
let _suppressed = Context::enter_telemetry_suppressed_scope();
let response = request.send(&[]).await;
assert_eq!(response.status(), 200);
let trace_id = TracedRequest::response_trace_id(&response);
assert_request_span_is_exported(&request, &trace_id);
let request_span = request.exporter.named("http.request").unwrap();
let stage_span = request.exporter.named("auth.resolve").unwrap_or_else(|| {
panic!(
"stage spans must stay recorded even with a suppressed ambient context; exported: {:?}",
request
.exporter
.finished()
.iter()
.map(|span| span.name.to_string())
.collect::<Vec<_>>()
)
});
assert_eq!(
stage_span.span_context.trace_id().to_string(),
request_span.span_context.trace_id().to_string()
);
assert_eq!(
stage_span.parent_span_id.to_string(),
request_span.span_context.span_id().to_string()
);
request.shutdown();
}