Support http/json protocol

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,18 +52,32 @@ impl LogExporter for OtlpHttpClient {
     }
 }
 
-#[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 => {
+            let json_struct = serde_json::to_string_pretty(&req).unwrap();
+            buf = json_struct.into();
+            ctype = "application/json";
+        }
+        _ => {
+            buf = req.encode_to_vec();
+            ctype = "application/x-protobuf";
+        }
+    };
+    Ok((buf, ctype))
 }
 
 #[cfg(not(feature = "http-proto"))]

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

@@ -48,20 +48,35 @@ impl MetricsClient for OtlpHttpClient {
     }
 }
 
-#[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")]
+        Protocol::HttpJson => {
+            let json_struct = serde_json::to_string_pretty(&req).unwrap();
+            buf = json_struct.into();
+            ctype = "application/json";
+        }
+        _ => {
+            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)> {
+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,37 @@ impl SpanExporter for OtlpHttpClient {
     }
 }
 
-#[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 => {
+            let json_struct = serde_json::to_string_pretty(&req).unwrap();
+            buf = json_struct.into();
+            ctype = "application/json";
+        }
+        _ => {
+            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(),
     ))
 }

opentelemetry-otlp/src/exporter/mod.rs

@@ -2,7 +2,7 @@
 //!
 //! OTLP supports sending data via different protocols and formats.
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 use crate::exporter::http::HttpExporterBuilder;
 #[cfg(feature = "grpc-tonic")]
 use crate::exporter::tonic::TonicExporterBuilder;
@@ -28,18 +28,32 @@
 /// Compression algorithm to use, defaults to none.
 pub const OTEL_EXPORTER_OTLP_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_COMPRESSION";
 
-#[cfg(feature = "http-proto")]
+#[cfg(all(
+    feature = "http-json",
+    not(all(feature = "grpc-tonic", feature = "http-proto"))
+))]
+/// Default protocol, using http-json.
+pub const OTEL_EXPORTER_OTLP_PROTOCOL_DEFAULT: &str = OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON;
+#[cfg(all(
+    feature = "http-proto",
+    not(all(feature = "grpc-tonic", feature = "http-json"))
+))]
 /// Default protocol, using http-proto.
 pub const OTEL_EXPORTER_OTLP_PROTOCOL_DEFAULT: &str = OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF;
-#[cfg(all(feature = "grpc-tonic", not(feature = "http-proto")))]
-/// Default protocol, using grpc as http-proto feature is not enabled.
+#[cfg(all(
+    feature = "grpc-tonic",
+    not(all(feature = "http-proto", feature = "http-json"))
+))]
+/// Default protocol, using grpc
 pub const OTEL_EXPORTER_OTLP_PROTOCOL_DEFAULT: &str = OTEL_EXPORTER_OTLP_PROTOCOL_GRPC;
-#[cfg(not(any(any(feature = "grpc-tonic", feature = "http-proto"))))]
+
+#[cfg(not(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json")))]
 /// Default protocol if no features are enabled.
 pub const OTEL_EXPORTER_OTLP_PROTOCOL_DEFAULT: &str = "";
 
 const OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF: &str = "http/protobuf";
 const OTEL_EXPORTER_OTLP_PROTOCOL_GRPC: &str = "grpc";
+const OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON: &str = "http/json";
 
 /// Max waiting time for the backend to process each signal batch, defaults to 10 seconds.
 pub const OTEL_EXPORTER_OTLP_TIMEOUT: &str = "OTEL_EXPORTER_OTLP_TIMEOUT";
@@ -50,7 +64,7 @@
 const OTEL_EXPORTER_OTLP_GRPC_ENDPOINT_DEFAULT: &str = "http://localhost:4317";
 const OTEL_EXPORTER_OTLP_HTTP_ENDPOINT_DEFAULT: &str = "http://localhost:4318";
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 pub(crate) mod http;
 #[cfg(feature = "grpc-tonic")]
 pub(crate) mod tonic;
@@ -109,9 +123,10 @@
 
 /// default protocol based on enabled features
 fn default_protocol() -> Protocol {
     match OTEL_EXPORTER_OTLP_PROTOCOL_DEFAULT {
         OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF => Protocol::HttpBinary,
         OTEL_EXPORTER_OTLP_PROTOCOL_GRPC => Protocol::Grpc,
+        OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON => Protocol::HttpJson,
         _ => Protocol::HttpBinary,
     }
 }
@@ -121,11 +136,12 @@
     match protocol {
         Protocol::Grpc => OTEL_EXPORTER_OTLP_GRPC_ENDPOINT_DEFAULT.to_string(),
         Protocol::HttpBinary => OTEL_EXPORTER_OTLP_HTTP_ENDPOINT_DEFAULT.to_string(),
+        Protocol::HttpJson => OTEL_EXPORTER_OTLP_HTTP_ENDPOINT_DEFAULT.to_string(),
     }
 }
 
 /// default user-agent headers
-#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
 fn default_headers() -> std::collections::HashMap<String, String> {
     let mut headers = std::collections::HashMap::new();
     headers.insert(
@@ -148,7 +164,7 @@
     }
 }
 
-#[cfg(feature = "http-proto")]
+#[cfg(any(feature = "http-proto", feature = "http-json"))]
 impl HasExportConfig for HttpExporterBuilder {
     fn export_config(&mut self) -> &mut ExportConfig {
         &mut self.exporter_config
@@ -210,7 +226,15 @@
     }
 }
 
-#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
+fn parse_header_string(value: &str) -> impl Iterator<Item = (&str, String)> {
+    value
+        .split_terminator(',')
+        .map(str::trim)
+        .filter_map(parse_header_key_value_string)
+}
+
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
 fn url_decode(value: &str) -> Option<String> {
     let mut result = String::with_capacity(value.len());
     let mut chars_to_decode = Vec::<u8>::new();
@@ -240,15 +264,7 @@
     }
 }
 
-#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
-fn parse_header_string(value: &str) -> impl Iterator<Item = (&str, String)> {
-    value
-        .split_terminator(',')
-        .map(str::trim)
-        .filter_map(parse_header_key_value_string)
-}
-
-#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
 fn parse_header_key_value_string(key_value_string: &str) -> Option<(&str, String)> {
     key_value_string
         .split_once('=')
@@ -262,9 +278,8 @@
 }
 
 #[cfg(test)]
-#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
 mod tests {
-
     pub(crate) fn run_env_test<T, F>(env_vars: T, f: F)
     where
         F: FnOnce(),
@@ -280,7 +295,7 @@
         )
     }
 
-    #[cfg(feature = "http-proto")]
+    #[cfg(any(feature = "http-proto", feature = "http-json"))]
     #[test]
     fn test_default_http_endpoint() {
         let exporter_builder = crate::new_exporter().http();
@@ -302,6 +317,39 @@
         );
     }
 
+    #[test]
+    fn test_default_protocol() {
+        #[cfg(all(
+            feature = "http-json",
+            not(all(feature = "grpc-tonic", feature = "http-proto"))
+        ))]
+        {
+            assert_eq!(
+                crate::exporter::default_protocol(),
+                crate::Protocol::HttpJson
+            );
+        }
+
+        #[cfg(all(
+            feature = "http-proto",
+            not(all(feature = "grpc-tonic", feature = "http-json"))
+        ))]
+        {
+            assert_eq!(
+                crate::exporter::default_protocol(),
+                crate::Protocol::HttpBinary
+            );
+        }
+
+        #[cfg(all(
+            feature = "grpc-tonic",
+            not(all(feature = "http-proto", feature = "http-json"))
+        ))]
+        {
+            assert_eq!(crate::exporter::default_protocol(), crate::Protocol::Grpc);
+        }
+    }
+
     #[test]
     fn test_url_decode() {
         let test_cases = vec![