Support http/json protocol

opentelemetry-otlp/CHANGELOG.md

@@ -8,6 +8,10 @@
 
 ### Added
 
+- Aded `http/json` support for all signals ([#1585])
+
+[#1585]: https://github.com/open-telemetry/opentelemetry-rust/pull/1585
+
 - Added `DeltaTemporalitySelector` ([#1568])
 
 [#1568]: https://github.com/open-telemetry/opentelemetry-rust/pull/1568

opentelemetry-otlp/Cargo.toml

@@ -42,6 +42,7 @@ reqwest = { workspace = true, optional = true }
 http = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"], optional = true }
 thiserror = { workspace = true }
+serde_json = { workspace = true, optional = true }
 
 [dev-dependencies]
 tokio-stream = { workspace = true, features = ["net"] }
@@ -58,7 +59,7 @@ metrics = ["opentelemetry/metrics", "opentelemetry_sdk/metrics", "opentelemetry-
 logs = ["opentelemetry/logs", "opentelemetry_sdk/logs", "opentelemetry-proto/logs"]
 
 # add ons
-serialize = ["serde"]
+serialize = ["serde", "serde_json"]
 
 default = ["grpc-tonic", "trace"]
 
@@ -73,6 +74,8 @@ http-proto = ["prost", "opentelemetry-http", "opentelemetry-proto/gen-tonic-mess
 reqwest-blocking-client = ["reqwest/blocking", "opentelemetry-http/reqwest"]
 reqwest-client = ["reqwest", "opentelemetry-http/reqwest"]
 reqwest-rustls = ["reqwest", "reqwest/rustls-tls-native-roots"]
+# http json
+http-json = ["serde_json", "prost", "opentelemetry-http", "opentelemetry-proto/gen-tonic-messages", "opentelemetry-proto/with-serde", "http", "trace", "metrics"]
 
 # test
 integration-testing = ["tonic", "prost", "tokio/full", "trace"]

opentelemetry-otlp/examples/basic-otlp-http/Cargo.toml

@@ -9,7 +9,7 @@ publish = false
 once_cell = { workspace = true }
 opentelemetry = { path = "../../../opentelemetry" }
 opentelemetry_sdk = { path = "../../../opentelemetry-sdk", features = ["rt-tokio", "metrics", "logs"] }
-opentelemetry-otlp = { path = "../..", features = ["http-proto", "reqwest-client", "logs"] }
+opentelemetry-otlp = { path = "../..", features = ["http-proto", "http-json", "reqwest-client", "logs"] }
 opentelemetry-appender-tracing = { path = "../../../opentelemetry-appender-tracing", default-features = false}
 opentelemetry-semantic-conventions = { path = "../../../opentelemetry-semantic-conventions" }
 

opentelemetry-otlp/src/exporter/http/logs.rs

@@ -52,21 +52,38 @@
     }
 }
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 fn build_body(logs: Vec<LogData>) -> LogResult<(Vec<u8>, &'static str)> {
+    use crate::exporter::default_protocol;
+    #[cfg(feature = "http-json")]
+    use crate::Protocol;
     use opentelemetry_proto::tonic::collector::logs::v1::ExportLogsServiceRequest;
     use prost::Message;
 
     let req = ExportLogsServiceRequest {
         resource_logs: logs.into_iter().map(Into::into).collect(),
     };
-    let mut buf = vec![];
-    req.encode(&mut buf).map_err(crate::Error::from)?;
-
-    Ok((buf, "application/x-protobuf"))
+    let buf;
+    let ctype;
+    match default_protocol() {
+        #[cfg(feature = "http-json")]
+        Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
+            Ok(json) => {
+                buf = json.into();
+                ctype = "application/json";
+                Ok((buf, ctype))
+            }
+            Err(e) => Err(LogError::from(e.to_string())),
+        },
+        _ => {
+            buf = req.encode_to_vec();
+            ctype = "application/x-protobuf";
+            Ok((buf, ctype))
+        }
+    }
 }
 
-#[cfg(not(feature = "http-proto"))]
+#[cfg(not(any(feature = "http-proto", feature = "http-json")))]
 fn build_body(logs: Vec<LogData>) -> LogResult<(Vec<u8>, &'static str)> {
     Err(LogsError::Other(
         "No http protocol configured. Enable one via `http-proto`".into(),

opentelemetry-otlp/src/exporter/http/metrics.rs

@@ -48,20 +48,39 @@
     }
 }
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 fn build_body(metrics: &mut ResourceMetrics) -> Result<(Vec<u8>, &'static str)> {
+    use crate::exporter::default_protocol;
+    #[cfg(feature = "http-json")]
+    use crate::Protocol;
     use prost::Message;
 
     let req: opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceRequest =
         (&*metrics).into();
-    let mut buf = vec![];
-    req.encode(&mut buf).map_err(crate::Error::from)?;
 
-    Ok((buf, "application/x-protobuf"))
+    let buf;
+    let ctype;
+    match default_protocol() {
+        #[cfg(feature = "http-json")]
+        #[cfg(feature = "http-json")]
+        Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
+            Ok(json) => {
+                buf = json.into();
+                ctype = "application/json";
+                Ok((buf, ctype))
+            }
+            Err(e) => Err(MetricsError::Other(e.to_string())),
+        },
+        _ => {
+            buf = req.encode_to_vec();
+            ctype = "application/x-protobuf";
+            Ok((buf, ctype))
+        }
+    }
 }
 
-#[cfg(not(feature = "http-proto"))]
-fn build_body(metrics: &mut ResourceMetrics) -> Result<(Vec<u8>, &'static str)> {
+#[cfg(not(any(feature = "http-proto", feature = "http-json")))]
+fn build_body(_metrics: &mut ResourceMetrics) -> Result<(Vec<u8>, &'static str)> {
     Err(MetricsError::Other(
         "No http protocol configured. Enable one via `http-proto`".into(),
     ))

opentelemetry-otlp/src/exporter/http/mod.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ExportConfig, Protocol, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS,
+    ExportConfig, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS,
     OTEL_EXPORTER_OTLP_TIMEOUT,
 };
 use http::{HeaderName, HeaderValue, Uri};
@@ -10,7 +10,7 @@ use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use super::{default_headers, parse_header_string};
+use super::{default_headers, default_protocol, parse_header_string};
 
 #[cfg(feature = "metrics")]
 mod metrics;
@@ -22,7 +22,7 @@ mod logs;
 mod trace;
 
 /// Configuration of the http transport
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 #[derive(Debug)]
 #[cfg_attr(
     all(
@@ -98,7 +98,7 @@ impl Default for HttpExporterBuilder {
     fn default() -> Self {
         HttpExporterBuilder {
             exporter_config: ExportConfig {
-                protocol: Protocol::HttpBinary,
+                protocol: default_protocol(),
                 ..ExportConfig::default()
             },
             http_config: HttpConfig {

opentelemetry-otlp/src/exporter/http/trace.rs

@@ -68,23 +68,90 @@
     }
 }
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 fn build_body(spans: Vec<SpanData>) -> TraceResult<(Vec<u8>, &'static str)> {
+    use crate::exporter::default_protocol;
+    #[cfg(feature = "http-json")]
+    use crate::Protocol;
     use opentelemetry_proto::tonic::collector::trace::v1::ExportTraceServiceRequest;
     use prost::Message;
 
     let req = ExportTraceServiceRequest {
         resource_spans: spans.into_iter().map(Into::into).collect(),
     };
-    let mut buf = vec![];
-    req.encode(&mut buf).map_err(crate::Error::from)?;
-
-    Ok((buf, "application/x-protobuf"))
+    let buf;
+    let ctype;
+    match default_protocol() {
+        #[cfg(feature = "http-json")]
+        Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
+            Ok(json) => {
+                buf = json.into();
+                ctype = "application/json";
+                Ok((buf, ctype))
+            }
+            Err(e) => Err(TraceError::from(e.to_string())),
+        },
+        _ => {
+            buf = req.encode_to_vec();
+            ctype = "application/x-protobuf";
+            Ok((buf, ctype))
+        }
+    }
 }
 
-#[cfg(not(feature = "http-proto"))]
+#[cfg(not(any(feature = "http-proto", feature = "http-json")))]
 fn build_body(spans: Vec<SpanData>) -> TraceResult<(Vec<u8>, &'static str)> {
     Err(TraceError::Other(
-        "No http protocol configured. Enable one via `http-proto`".into(),
+        "No http protocol configured. Enable one via `http-proto` or `http-json`".into(),
     ))
 }
+
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
+mod tests {
+    #[test]
+    fn test_build_body() {
+        use crate::exporter::http::trace::build_body;
+        use opentelemetry::trace::{
+            SpanContext, SpanId, SpanKind, Status, TraceFlags, TraceId, TraceState,
+        };
+        use opentelemetry_sdk::export::trace::SpanData;
+        use opentelemetry_sdk::trace::{SpanEvents, SpanLinks};
+        use opentelemetry_sdk::Resource;
+        use std::{borrow::Cow, time::SystemTime};
+
+        let span_data = (0..5)
+            .map(|_| SpanData {
+                span_context: SpanContext::new(
+                    TraceId::from_u128(12),
+                    SpanId::from_u64(12),
+                    TraceFlags::default(),
+                    false,
+                    TraceState::default(),
+                ),
+                parent_span_id: SpanId::from_u64(12),
+                span_kind: SpanKind::Client,
+                name: Default::default(),
+                start_time: SystemTime::now(),
+                end_time: SystemTime::now(),
+                attributes: Vec::new(),
+                dropped_attributes_count: 0,
+                events: SpanEvents::default(),
+                links: SpanLinks::default(),
+                status: Status::Unset,
+                resource: Cow::Owned(Resource::empty()),
+                instrumentation_lib: Default::default(),
+            })
+            .collect::<Vec<SpanData>>();
+
+        let result = build_body(span_data).unwrap();
+        match crate::exporter::default_protocol() {
+            #[cfg(feature = "http-json")]
+            crate::Protocol::HttpJson => {
+                assert_eq!(result.1, "application/json")
+            }
+            _ => {
+                assert_eq!(result.1, "application/x-protobuf")
+            }
+        };
+    }
+}