[SVLS-8626] Add JSON encoding support for OTLP trace payloads

- Add OtlpEncoding enum with Protobuf and Json variants
- Update Processor::process() to decode based on encoding
- Update v1_traces handler to detect Content-Type header
- Return matching Content-Type in responses per OTLP spec
- Add unit tests for encoding detection and processing
- Add integration tests for end-to-end encoding verification
- Update package-lock.json with OTLP HTTP exporter dependency

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jchrostek-dd

bottlecap/src/otlp/agent.rs

@@ -19,7 +19,7 @@ use tracing::{debug, error};
 use crate::{
     config::Config,
     http::{extract_request_body, handler_not_found},
-    otlp::processor::Processor as OtlpProcessor,
+    otlp::processor::{OtlpEncoding, Processor as OtlpProcessor},
     tags::provider,
     traces::{
         stats_generator::StatsGenerator, trace_aggregator::SendDataBuilderInfo,
@@ -141,24 +141,33 @@ impl Agent {
         >,
         request: Request,
     ) -> Response {
+        let content_type = request
+            .headers()
+            .get(header::CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .map(String::from);
+        let encoding = OtlpEncoding::from_content_type(content_type.as_deref());
+
         let (parts, body) = match extract_request_body(request).await {
             Ok(r) => r,
             Err(e) => {
                 error!("OTLP | Failed to extract request body: {e}");
                 return Self::otlp_error_response(
                     StatusCode::BAD_REQUEST,
                     format!("Failed to extract request body: {e}"),
+                    encoding,
                 );
             }
         };
 
-        let traces = match processor.process(&body) {
+        let traces = match processor.process(&body, encoding) {
             Ok(traces) => traces,
             Err(e) => {
                 error!("OTLP | Failed to process request: {:?}", e);
                 return Self::otlp_error_response(
                     StatusCode::INTERNAL_SERVER_ERROR,
                     format!("Failed to process request: {e}"),
+                    encoding,
                 );
             }
         };
@@ -170,6 +179,7 @@ impl Agent {
             return Self::otlp_error_response(
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "Not sending traces, processor returned empty data".to_string(),
+                encoding,
             );
         }
 
@@ -192,6 +202,7 @@ impl Agent {
                 return Self::otlp_error_response(
                     StatusCode::INTERNAL_SERVER_ERROR,
                     format!("Error sending traces to the trace aggregator: {err}"),
+                    encoding,
                 );
             }
         }
@@ -206,49 +217,88 @@ impl Agent {
             error!("OTLP | Error sending traces to the stats concentrator: {err}");
         }
 
-        Self::otlp_success_response()
+        Self::otlp_success_response(encoding)
     }
 
-    fn otlp_error_response(status_code: StatusCode, message: String) -> Response {
-        let status = Status {
-            code: i32::from(status_code.as_u16()),
-            message: message.clone(),
-            details: vec![],
+    fn otlp_error_response(
+        status_code: StatusCode,
+        message: String,
+        encoding: OtlpEncoding,
+    ) -> Response {
+        let body = match encoding {
+            OtlpEncoding::Json => {
+                let json_error = serde_json::json!({
+                    "code": status_code.as_u16(),
+                    "message": message
+                });
+                match serde_json::to_vec(&json_error) {
+                    Ok(buf) => buf,
+                    Err(e) => {
+                        error!("OTLP | Failed to encode error response as JSON: {e}");
+                        return (status_code, [(header::CONTENT_TYPE, "text/plain")], message)
+                            .into_response();
+                    }
+                }
+            }
+            OtlpEncoding::Protobuf => {
+                let status = Status {
+                    code: i32::from(status_code.as_u16()),
+                    message: message.clone(),
+                    details: vec![],
+                };
+                let mut buf = Vec::new();
+                if let Err(e) = status.encode(&mut buf) {
+                    error!("OTLP | Failed to encode error response as Protobuf: {e}");
+                    return (status_code, [(header::CONTENT_TYPE, "text/plain")], message)
+                        .into_response();
+                }
+                buf
+            }
         };
 
-        let mut buf = Vec::new();
-        if let Err(e) = status.encode(&mut buf) {
-            error!("OTLP | Failed to encode error response: {e}");
-            return (status_code, [(header::CONTENT_TYPE, "text/plain")], message).into_response();
-        }
-
         (
             status_code,
-            [(header::CONTENT_TYPE, "application/x-protobuf")],
-            buf,
+            [(header::CONTENT_TYPE, encoding.content_type())],
+            body,
         )
             .into_response()
     }
 
-    fn otlp_success_response() -> Response {
+    fn otlp_success_response(encoding: OtlpEncoding) -> Response {
         let response = ExportTraceServiceResponse {
             partial_success: None,
         };
 
-        let mut buf = Vec::new();
-        if let Err(e) = response.encode(&mut buf) {
-            error!("OTLP | Failed to encode success response: {e}");
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Failed to encode response".to_string(),
-            )
-                .into_response();
-        }
+        let body = match encoding {
+            OtlpEncoding::Json => match serde_json::to_vec(&response) {
+                Ok(buf) => buf,
+                Err(e) => {
+                    error!("OTLP | Failed to encode success response as JSON: {e}");
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        "Failed to encode response".to_string(),
+                    )
+                        .into_response();
+                }
+            },
+            OtlpEncoding::Protobuf => {
+                let mut buf = Vec::new();
+                if let Err(e) = response.encode(&mut buf) {
+                    error!("OTLP | Failed to encode success response as Protobuf: {e}");
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        "Failed to encode response".to_string(),
+                    )
+                        .into_response();
+                }
+                buf
+            }
+        };
 
         (
             StatusCode::OK,
-            [(header::CONTENT_TYPE, "application/x-protobuf")],
-            buf,
+            [(header::CONTENT_TYPE, encoding.content_type())],
+            body,
         )
             .into_response()
     }

bottlecap/src/otlp/processor.rs

@@ -5,6 +5,30 @@ use std::{error::Error, sync::Arc};
 
 use crate::{config::Config, otlp::transform::otel_resource_spans_to_dd_spans};
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum OtlpEncoding {
+    Protobuf,
+    Json,
+}
+
+impl OtlpEncoding {
+    #[must_use]
+    pub fn from_content_type(content_type: Option<&str>) -> Self {
+        match content_type {
+            Some(ct) if ct.starts_with("application/json") => OtlpEncoding::Json,
+            _ => OtlpEncoding::Protobuf,
+        }
+    }
+
+    #[must_use]
+    pub fn content_type(&self) -> &'static str {
+        match self {
+            OtlpEncoding::Json => "application/json",
+            OtlpEncoding::Protobuf => "application/x-protobuf",
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct Processor {
     config: Arc<Config>,
@@ -16,9 +40,21 @@ impl Processor {
         Self { config }
     }
 
-    pub fn process(&self, body: &[u8]) -> Result<Vec<Vec<DatadogSpan>>, Box<dyn Error>> {
-        // Decode the OTLP HTTP request
-        let request = ExportTraceServiceRequest::decode(body)?;
+    pub fn process(
+        &self,
+        body: &[u8],
+        encoding: OtlpEncoding,
+    ) -> Result<Vec<Vec<DatadogSpan>>, Box<dyn Error>> {
+        let request = match encoding {
+            OtlpEncoding::Json => {
+                tracing::debug!("Decoding OTLP traces as JSON");
+                serde_json::from_slice::<ExportTraceServiceRequest>(body)?
+            }
+            OtlpEncoding::Protobuf => {
+                tracing::debug!("Decoding OTLP traces as Protobuf");
+                ExportTraceServiceRequest::decode(body)?
+            }
+        };
 
         let mut spans: Vec<Vec<DatadogSpan>> = Vec::new();
         for resource_spans in &request.resource_spans {

integration-tests/lambda/otlp-node/package-lock.json

@@ -5,6 +5,7 @@
   "main": "index.js",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.54.2",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.54.2",
     "@opentelemetry/otlp-transformer": "^0.54.2",
     "@opentelemetry/resources": "^1.28.0",