Feature: Add request_id in logs

rust/lit-core/lit-api-core/src/context/mod.rs

@@ -15,6 +15,8 @@ use tracing::{Span, info_span};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 use uuid::Uuid;
 
+use lit_observability::logging::set_request_context;
+
 use crate::error::{EC, Error, Result, conversion_err_code, validation_err_code};
 
 pub const HEADER_KEY_X_CORRELATION_ID: &str = "X-Correlation-Id";
@@ -167,8 +169,19 @@ impl<'r> FromRequest<'r> for Tracing {
     type Error = crate::error::Error;
 
     async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
-        let correlation_id =
-            extract_correlation_id(req).unwrap_or_else(|| format!("LD-{}", Uuid::new_v4()));
+        let (request_id, correlation_id) = extract_request_and_correlation_ids(req);
+
+        // Generate fallback ID only if BOTH headers are missing
+        let fallback_id = || format!("LD-{}", Uuid::new_v4());
+        let correlation_id = correlation_id.unwrap_or_else(&fallback_id);
+        let request_id = request_id.unwrap_or_else(|| correlation_id.clone());
+
+        // Set request context on the current span. This centralizes context storage:
+        // 1. Span extensions (RequestContext) - for log injection in OTLP and stdout
+        // 2. OTel span attributes - for distributed tracing correlation
+        // This ensures other components (like set_request_id_on_span) can find
+        // this context via get_request_context() and avoid generating duplicate IDs.
+        set_request_context(Some(request_id), Some(correlation_id.clone()));
 
         let mut tracing = Self::new(correlation_id);
         apply_req_tracing_fields(req, &mut tracing);
@@ -227,7 +240,16 @@ impl<'r> FromRequest<'r> for TracingRequired {
     type Error = crate::error::Error;
 
     async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
-        if let Some(correlation_id) = extract_correlation_id(req) {
+        let (request_id, correlation_id) = extract_request_and_correlation_ids(req);
+
+        // TracingRequired requires at least one header
+        if let Some(correlation_id) = correlation_id {
+            // Preserve distinct values when both headers are present
+            let request_id = request_id.unwrap_or_else(|| correlation_id.clone());
+
+            // Set request context (span extensions + OTel attributes) for consistency
+            set_request_context(Some(request_id), Some(correlation_id.clone()));
+
             let mut tracing = Self::new(correlation_id);
             apply_req_tracing_fields(req, &mut tracing);
 
@@ -257,12 +279,23 @@ where
     TRACING.scope(Box::new(tracing), f)
 }
 
-pub(crate) fn extract_correlation_id(req: &Request<'_>) -> Option<String> {
-    req.headers()
-        .get(HEADER_KEY_X_CORRELATION_ID)
-        .next()
-        .or_else(|| req.headers().get(HEADER_KEY_X_REQUEST_ID).next())
-        .map(|val| val.to_string())
+/// Extracts both request_id and correlation_id from headers, preserving distinct values.
+/// Returns (request_id, correlation_id) tuple.
+/// - request_id: X-Request-Id header, falls back to X-Correlation-Id
+/// - correlation_id: X-Correlation-Id header, falls back to X-Request-Id
+pub(crate) fn extract_request_and_correlation_ids(
+    req: &Request<'_>,
+) -> (Option<String>, Option<String>) {
+    let x_request_id = req.headers().get(HEADER_KEY_X_REQUEST_ID).next().map(|v| v.to_string());
+    let x_correlation_id =
+        req.headers().get(HEADER_KEY_X_CORRELATION_ID).next().map(|v| v.to_string());
+
+    // request_id: prefer X-Request-Id, fall back to X-Correlation-Id
+    let request_id = x_request_id.clone().or_else(|| x_correlation_id.clone());
+    // correlation_id: prefer X-Correlation-Id, fall back to X-Request-Id
+    let correlation_id = x_correlation_id.or(x_request_id);
+
+    (request_id, correlation_id)
 }
 
 pub(crate) fn apply_req_tracing_fields(req: &Request<'_>, tracing: &mut (impl Tracer + 'static)) {

rust/lit-core/lit-observability/Cargo.toml

@@ -19,7 +19,6 @@ flume = { version = "0.11", optional = true }
 hyper-util.workspace = true
 nu-ansi-term = { version = "0.50.1" }
 opentelemetry.workspace = true
-opentelemetry-appender-tracing = { version = "0.5.0", default-features = false }
 opentelemetry-otlp = { workspace = true, features = ["logs"] }
 opentelemetry-semantic-conventions.workspace = true
 opentelemetry_sdk = { workspace = true, features = ["logs"] }

rust/lit-core/lit-observability/src/lib.rs

@@ -3,11 +3,10 @@ use std::str::FromStr;
 pub use config::LitObservabilityConfig;
 use error::unexpected_err;
 use lit_core::config::LitConfig;
-use logging::init_logger_provider;
+use logging::{ContextAwareOtelLogLayer, CustomEventFormatter, init_logger_provider};
 use metrics::init_metrics_provider;
 use net::init_tonic_exporter_builder;
 use opentelemetry::trace::TracerProvider;
-use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::metrics::SdkMeterProvider;
@@ -80,8 +79,7 @@ pub async fn create_providers(
     };
     let logger_provider = init_logger_provider(tonic_exporter_builder, resource.clone())?;
 
-    // Create a new OpenTelemetryTracingBridge using the above LoggerProvider.
-    let tracing_bridge_layer = OpenTelemetryTracingBridge::new(&logger_provider);
+    let context_aware_log_layer = ContextAwareOtelLogLayer::new(&logger_provider);
 
     // Add a tracing filter to filter events from crates used by opentelemetry-otlp.
     // The filter levels are set as follows:
@@ -101,10 +99,12 @@ pub async fn create_providers(
         .add_directive("h2=error".parse().unwrap())
         .add_directive("reqwest=error".parse().unwrap());
 
+    let custom_formatter = CustomEventFormatter::default();
+
     let sub = tracing_subscriber::registry()
         .with(level_filter)
-        .with(fmt::layer())
-        .with(tracing_bridge_layer)
+        .with(fmt::layer().event_format(custom_formatter))
+        .with(context_aware_log_layer)
         .with(MetricsLayer::new(meter_provider.clone()))
         .with(OpenTelemetryLayer::new(tracer));