feat(logs): euler-parity golden-line sources + mapping config (on #2075)

crates/common/external-services/src/service.rs

@@ -578,7 +578,10 @@ pub struct EventProcessingParams<'a> {
         response.error_message = Empty,
         response.status_code = Empty,
         message_ = "Golden Log Line (outgoing)",
+        // `latency` is the pre-existing human-readable string; `latency_ms` is the same
+        // duration as a plain number of milliseconds, for numeric downstream consumers.
         latency = Empty,
+        latency_ms = Empty,
     )
 )]
 #[allow(clippy::too_many_arguments)]
@@ -1087,6 +1090,8 @@ where
 
     let elapsed = start.elapsed().as_millis();
     tracing::Span::current().record("latency", elapsed);
+    // Additive numeric latency alongside the existing string `latency`.
+    tracing::Span::current().record("latency_ms", u64::try_from(elapsed).unwrap_or_default());
     // Apply outgoing log fields (transformations + static values) before emitting the golden log line
     #[cfg(feature = "log-transformations")]
     if event_params.log_fields_enabled {

crates/common/ucs_env/Cargo.toml

@@ -71,4 +71,4 @@ otel = ["dep:opentelemetry", "dep:opentelemetry-otlp", "dep:opentelemetry_sdk"]
 log-transformations = ["common_utils/log-transformations"]
 
 [lints]
-workspace = true
+workspace = true

crates/grpc-server/grpc-server/src/http/error.rs

@@ -225,6 +225,15 @@ fn grpc_code_to_http_status(code: tonic::Code) -> StatusCode {
     }
 }
 
+/// The HTTP status the caller receives for a gRPC error: the connector's exact 4xx/5xx when the
+/// details carry one, else the gRPC-to-HTTP fallback. Shared by the HTTP response and the golden
+/// line so both report the same status.
+pub fn http_status_for_status(status: &tonic::Status) -> StatusCode {
+    let details = extract_error_details_from_status(status);
+    connector_http_status_from_error_details(details.as_ref())
+        .unwrap_or_else(|| grpc_code_to_http_status(status.code()))
+}
+
 // Convert tonic::Status to HTTP error
 impl From<tonic::Status> for HttpError {
     fn from(status: tonic::Status) -> Self {

crates/grpc-server/grpc-server/src/utils.rs

@@ -41,6 +41,9 @@ pub fn record_fields_from_header<B: hyper::body::Body>(request: &Request<B>) ->
         "request",
         uri = %url_path,
         version = ?request.version(),
+        // `action` = the real HTTP verb (GET/POST/…). gRPC-over-HTTP2 is always POST;
+        // the HTTP gateway carries the true verb.
+        action = %request.method(),
         tenant_id = tracing::field::Empty,
         request_id = tracing::field::Empty,
         execution_mode = tracing::field::Empty,
@@ -276,21 +279,51 @@ where
         ..
     } = metadata_payload;
     let current_span = tracing::Span::current();
+    let masked_body = hyperswitch_masking::masked_serialize(&request_data.payload)
+        .map_err(|e| tracing::error!("Masked serialization error: {:?}", e))
+        .ok();
     let connector_name = connector.get_connector_name();
     current_span.record("service_name", service_name);
-    match hyperswitch_masking::masked_serialize(&request_data.payload) {
-        Ok(masked_value) => {
-            record_json_fields_on_span(vec![("request_body", masked_value)]);
+    match masked_body.as_ref() {
+        Some(masked_value) => {
+            record_json_fields_on_span(vec![("request_body", masked_value.clone())]);
         }
-        Err(e) => {
-            tracing::error!("Masked serialization error: {:?}", e);
+        None => {
             current_span.record("request_body", "<masked serialization error>");
         }
     };
     current_span.record("gateway", connector_name);
     current_span.record("merchant_id", merchant_id);
     current_span.record("tenant_id", tenant_id);
     current_span.record("request_id", request_id);
+
+    // Standard request identifiers (order id / customer id / transaction id) surfaced as flat
+    // span fields so the log-field mapping can source them by flat key (it cannot reach into
+    // `request_body`), without declaring them on every handler's `#[instrument]`.
+    if let Some(ids) = masked_body.as_ref().map(|body| {
+        [
+            (
+                "merchant_order_id",
+                body.get("merchant_order_id").and_then(Value::as_str),
+            ),
+            (
+                "customer_id",
+                body.get("customer")
+                    .and_then(|customer| customer.get("id"))
+                    .and_then(Value::as_str),
+            ),
+            (
+                "merchant_transaction_id",
+                body.get("merchant_transaction_id").and_then(Value::as_str),
+            ),
+        ]
+    }) {
+        record_json_fields_on_span(
+            ids.into_iter()
+                .filter_map(|(key, value)| value.map(|value| (key, Value::from(value))))
+                .collect(),
+        );
+    }
     tracing::info!("Golden Log Line (incoming - request)");
     Ok(())
 }
@@ -306,6 +339,10 @@ pub fn log_after_initialization<T>(
 
     match &result {
         Ok(response) => {
+            // Additive numeric `res_code` (success). `status_code` is left untouched so
+            // existing consumers of the gRPC-code field don't break.
+            record_json_fields_on_span(vec![("res_code", Value::from(200_i64))]);
+
             let res_ref = response.get_ref();
 
             // Record response_body as structured JSON with masking
@@ -340,7 +377,12 @@ pub fn log_after_initialization<T>(
         }
         Err(status) => {
             current_span.record("error_message", status.message());
+            // Backward-compatible: keep main's gRPC code-name string on `status_code`.
             current_span.record("status_code", status.code().to_string());
+            // Additive numeric `res_code`: connector-aware HTTP status (e.g. 422) — matches the
+            // HTTP response the caller receives, not the coarse gRPC code.
+            let http_status = crate::http::error::http_status_for_status(status).as_u16();
+            record_json_fields_on_span(vec![("res_code", Value::from(i64::from(http_status)))]);
         }
     }
     // Apply unified log fields (transformations + static values) before emitting the golden log line
@@ -356,6 +398,15 @@ pub fn log_after_initialization<T>(
     tracing::info!("Golden Log Line (incoming - response)");
 }
 
+/// Record the additive numeric `latency_ms` on the current span. Shared by the streaming and
+/// non-streaming logging wrappers to avoid drift.
+fn record_latency_ms(duration: u128) {
+    record_json_fields_on_span(vec![(
+        "latency_ms",
+        Value::from(u64::try_from(duration).unwrap_or_default()),
+    )]);
+}
+
 /// Generic gRPC logging wrapper that accepts a custom parser function.
 /// This allows different parsing strategies for different flow types
 /// (e.g., authenticated flows vs unauthenticated webhook flows).
@@ -398,6 +449,8 @@ where
 
         let duration = start_time.elapsed().as_millis();
         current_span.record("response_time", duration);
+        // Additive numeric latency alongside the existing `response_time`.
+        record_latency_ms(duration);
         result
     }
     .await;
@@ -466,6 +519,8 @@ where
 
         let duration = start_time.elapsed().as_millis();
         current_span.record("response_time", duration);
+        // Additive numeric latency alongside the existing `response_time`.
+        record_latency_ms(duration);
         result
     }
     .await;