исправить: закрыть ревью сквозной корреляции

apps/admin-api/tests/integration/community_access_usage.rs

@@ -41,8 +41,6 @@ const TEST_PASSWORD_PEPPER: &str = "test-password-pepper";
 const TEST_SESSION_SECRET: &str = "test-session-secret";
 const TEST_MASTER_KEY: &str = "test-master-key";
 
-mod history_loss;
-
 struct TestServer {
     base_url: String,
     shutdown: Option<tokio::sync::oneshot::Sender<()>>,

apps/admin-api/tests/integration/community_access_usage/history_loss.rs

@@ -1,141 +0,0 @@
-use std::sync::{
-    Arc,
-    atomic::{AtomicUsize, Ordering},
-};
-
-use axum::{Json, Router, extract::State, routing::post};
-use tokio::{net::TcpListener, sync::Notify};
-
-use super::*;
-
-#[tokio::test(flavor = "multi_thread")]
-#[serial]
-async fn preserves_external_success_when_invocation_history_is_lost() {
-    let registry = test_registry().await;
-    let registry_for_failure = registry.clone();
-    let storage_root = test_storage_root("observability_history_loss");
-    let upstream = spawn_blocking_upstream_server().await;
-    let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
-    let client = authorized_client(&base_url).await;
-
-    let created = client
-        .post(format!("{base_url}/operations"))
-        .json(&test_operation_payload(
-            &upstream.base_url,
-            "crm_history_loss",
-        ))
-        .send()
-        .await
-        .unwrap()
-        .json::<Value>()
-        .await
-        .unwrap();
-    let operation_id = created["operation_id"].as_str().unwrap().to_owned();
-    let request_client = client.clone();
-    let request_url = format!("{base_url}/operations/{operation_id}/test-runs");
-    let before = crank_observability::operational_incident_total(
-        crank_observability::OperationalIncident::InvocationHistoryLost,
-    );
-
-    let request = tokio::spawn(async move {
-        request_client
-            .post(request_url)
-            .header("x-request-id", "req_dc08_admin")
-            .json(&json!({
-                "version": 1,
-                "input": { "email": "dc08-canary-secret@example.com" }
-            }))
-            .send()
-            .await
-            .unwrap()
-    });
-
-    upstream.started.notified().await;
-    registry_for_failure
-        .delete_operation(
-            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
-            &OperationId::new(operation_id.clone()),
-        )
-        .await
-        .unwrap();
-    upstream.release.notify_one();
-
-    let response = request.await.unwrap();
-    assert_eq!(response.status(), reqwest::StatusCode::OK);
-    assert_eq!(
-        response.headers()["x-request-id"].to_str().unwrap(),
-        "req_dc08_admin"
-    );
-    let body = response.json::<Value>().await.unwrap();
-    assert_eq!(body["ok"], true);
-    assert_eq!(body["response_preview"]["id"], "lead_123");
-    assert_eq!(upstream.calls.load(Ordering::SeqCst), 1);
-    assert!(
-        crank_observability::operational_incident_total(
-            crank_observability::OperationalIncident::InvocationHistoryLost
-        ) > before
-    );
-
-    let logs = client
-        .get(format!("{base_url}/logs?period=7d"))
-        .send()
-        .await
-        .unwrap()
-        .json::<Value>()
-        .await
-        .unwrap();
-    assert!(logs["items"].as_array().unwrap().is_empty());
-}
-
-struct BlockingUpstream {
-    base_url: String,
-    started: Arc<Notify>,
-    release: Arc<Notify>,
-    calls: Arc<AtomicUsize>,
-}
-
-#[derive(Clone)]
-struct BlockingUpstreamState {
-    started: Arc<Notify>,
-    release: Arc<Notify>,
-    calls: Arc<AtomicUsize>,
-}
-
-async fn spawn_blocking_upstream_server() -> BlockingUpstream {
-    let state = BlockingUpstreamState {
-        started: Arc::new(Notify::new()),
-        release: Arc::new(Notify::new()),
-        calls: Arc::new(AtomicUsize::new(0)),
-    };
-    let app = Router::new()
-        .route("/crm/leads", post(blocking_create_lead))
-        .with_state(state.clone());
-    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-    let address = listener.local_addr().unwrap();
-
-    tokio::spawn(async move {
-        axum::serve(listener, app).await.unwrap();
-    });
-
-    BlockingUpstream {
-        base_url: format!("http://{address}"),
-        started: state.started,
-        release: state.release,
-        calls: state.calls,
-    }
-}
-
-async fn blocking_create_lead(
-    State(state): State<BlockingUpstreamState>,
-    Json(payload): Json<Value>,
-) -> Json<Value> {
-    state.calls.fetch_add(1, Ordering::SeqCst);
-    state.started.notify_one();
-    state.release.notified().await;
-
-    Json(json!({
-        "id": "lead_123",
-        "status": "created",
-        "email": payload["email"]
-    }))
-}

apps/admin-api/tests/integration/request_context.rs

@@ -7,7 +7,7 @@ use admin_api::request_context::{REQUEST_ID_HEADER, apply_request_context};
 use axum::{
     Router,
     body::Body,
-    http::{HeaderMap, Request, StatusCode},
+    http::{HeaderMap, HeaderValue, Request, StatusCode},
     routing::get,
 };
 use crank_observability::{
@@ -16,12 +16,14 @@ use crank_observability::{
 use opentelemetry::{global, trace::TracerProvider as _};
 use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::SdkTracerProvider};
 use tower::ServiceExt;
-use tracing::instrument::WithSubscriber;
 use tracing_subscriber::{fmt::MakeWriter, layer::SubscriberExt};
 use uuid::Version;
 
+static TRACING_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
+
 #[tokio::test(flavor = "current_thread")]
 async fn logs_request_completion_and_rejects_untrusted_values() {
+    let _tracing_test_guard = TRACING_TEST_LOCK.lock().await;
     let writer = SharedLogWriter::default();
     let subscriber = crank_observability::build_subscriber(
         ObservabilityConfig::new(
@@ -33,6 +35,7 @@ async fn logs_request_completion_and_rejects_untrusted_values() {
     )
     .unwrap();
     let dispatch = tracing::Dispatch::new(subscriber);
+    let _dispatch_guard = tracing::dispatcher::set_default(&dispatch);
     let app = probe_app();
 
     let response = app
@@ -44,7 +47,6 @@ async fn logs_request_completion_and_rejects_untrusted_values() {
                 .body(Body::empty())
                 .unwrap(),
         )
-        .with_subscriber(dispatch.clone())
         .await
         .unwrap();
 
@@ -73,7 +75,6 @@ async fn logs_request_completion_and_rejects_untrusted_values() {
                 .body(Body::empty())
                 .unwrap(),
         )
-        .with_subscriber(dispatch)
         .await
         .unwrap();
     let generated = invalid_response.headers()[REQUEST_ID_HEADER.as_str()]
@@ -88,12 +89,14 @@ async fn logs_request_completion_and_rejects_untrusted_values() {
 
 #[tokio::test(flavor = "current_thread")]
 async fn covers_valid_invalid_and_absent_traceparent() {
+    let _tracing_test_guard = TRACING_TEST_LOCK.lock().await;
     global::set_text_map_propagator(TraceContextPropagator::new());
     let provider = SdkTracerProvider::builder().build();
     let tracer = provider.tracer("admin-request-context-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 = trace_probe_app();
 
     let valid = observed_trace_id(
@@ -109,7 +112,6 @@ async fn covers_valid_invalid_and_absent_traceparent() {
                     .body(Body::empty())
                     .unwrap(),
             )
-            .with_subscriber(dispatch.clone())
             .await
             .unwrap(),
     );
@@ -122,7 +124,6 @@ async fn covers_valid_invalid_and_absent_traceparent() {
                     .body(Body::empty())
                     .unwrap(),
             )
-            .with_subscriber(dispatch.clone())
             .await
             .unwrap(),
     );
@@ -133,7 +134,6 @@ async fn covers_valid_invalid_and_absent_traceparent() {
                 .body(Body::empty())
                 .unwrap(),
         )
-        .with_subscriber(dispatch)
         .await
         .unwrap(),
     );
@@ -145,6 +145,35 @@ async fn covers_valid_invalid_and_absent_traceparent() {
     provider.shutdown().unwrap();
 }
 
+#[tokio::test(flavor = "current_thread")]
+async fn replaces_multiple_request_id_headers_with_one_uuid_v7() {
+    let _tracing_test_guard = TRACING_TEST_LOCK.lock().await;
+    let dispatch = tracing::Dispatch::new(tracing_subscriber::registry());
+    let _dispatch_guard = tracing::dispatcher::set_default(&dispatch);
+    let mut request = Request::builder()
+        .uri("/probe")
+        .body(Body::empty())
+        .unwrap();
+    request.headers_mut().append(
+        REQUEST_ID_HEADER,
+        HeaderValue::from_static("first-request-id"),
+    );
+    request.headers_mut().append(
+        REQUEST_ID_HEADER,
+        HeaderValue::from_static("second-request-id"),
+    );
+
+    let response = probe_app().oneshot(request).await.unwrap();
+    let generated = response.headers()[REQUEST_ID_HEADER].to_str().unwrap();
+
+    assert_ne!(generated, "first-request-id");
+    assert_ne!(generated, "second-request-id");
+    assert_eq!(
+        uuid::Uuid::parse_str(generated).unwrap().get_version(),
+        Some(Version::SortRand)
+    );
+}
+
 fn probe_app() -> Router {
     Router::new()
         .route("/probe", get(|| async { "ok" }))