chore(otlp): Make invalid proto combos unrepresentable

Author: scottgerring

opentelemetry-otlp/CHANGELOG.md

@@ -4,6 +4,25 @@
 
 - Add partial success response handling for OTLP exporters (traces, metrics, logs) per OTLP spec. Exporters now log warnings when the server returns partial success responses with rejected items and error messages. [#865](https://github.com/open-telemetry/opentelemetry-rust/issues/865)
 - Refactor `internal-logs` feature in `opentelemetry-otlp` to reduce unnecessary dependencies[3191](https://github.com/open-telemetry/opentelemetry-rust/pull/3192)
+- **Breaking** Replace ambiguous `Protocol` enum with type-safe HTTP encoding API [#3082](https://github.com/open-telemetry/opentelemetry-rust/issues/3082)
+  - Removed `protocol` field from `ExportConfig` and `with_protocol()` method from `WithExportConfig` trait
+  - Added new `HttpEncoding` enum with `Protobuf` and `Json` variants for HTTP transport
+  - Added HTTP-specific methods: `with_http_encoding(encoding)`, `with_json_encoding()`, `with_protobuf_encoding()`
+  - This change makes invalid protocol/transport combinations impossible to express to simplify the user experience
+  - Migration example:
+    ```rust
+    // Before:
+    SpanExporter::builder()
+        .with_http()
+        .with_protocol(Protocol::HttpBinary)
+        .build()
+
+    // After:
+    SpanExporter::builder()
+        .with_http()
+        .with_protobuf_encoding()
+        .build()
+    ```
 
 ## 0.31.0
 

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -4,8 +4,8 @@ use opentelemetry::{
     InstrumentationScope, KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::WithExportConfig;
-use opentelemetry_otlp::{LogExporter, MetricExporter, Protocol, SpanExporter};
+use opentelemetry_otlp::WithHttpConfig;
+use opentelemetry_otlp::{LogExporter, MetricExporter, SpanExporter};
 use opentelemetry_sdk::Resource;
 use opentelemetry_sdk::{
     logs::SdkLoggerProvider, metrics::SdkMeterProvider, trace::SdkTracerProvider,
@@ -29,7 +29,7 @@ fn get_resource() -> Resource {
 fn init_logs() -> SdkLoggerProvider {
     let exporter = LogExporter::builder()
         .with_http()
-        .with_protocol(Protocol::HttpBinary)
+        .with_protobuf_encoding() // can be changed to .with_json_encoding() to export in JSON format
         .build()
         .expect("Failed to create log exporter");
 
@@ -42,7 +42,7 @@ fn init_logs() -> SdkLoggerProvider {
 fn init_traces() -> SdkTracerProvider {
     let exporter = SpanExporter::builder()
         .with_http()
-        .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
+        .with_protobuf_encoding() // can be changed to .with_json_encoding() to export in JSON format
         .build()
         .expect("Failed to create trace exporter");
 
@@ -55,7 +55,7 @@ fn init_traces() -> SdkTracerProvider {
 fn init_metrics() -> SdkMeterProvider {
     let exporter = MetricExporter::builder()
         .with_http()
-        .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
+        .with_protobuf_encoding() // can be changed to .with_json_encoding() to export in JSON format
         .build()
         .expect("Failed to create metric exporter");
 

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

@@ -1,5 +1,4 @@
-use super::OtlpHttpClient;
-use crate::Protocol;
+use super::{HttpEncoding, OtlpHttpClient};
 use opentelemetry::{otel_debug, otel_warn};
 use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
 use opentelemetry_sdk::logs::{LogBatch, LogExporter};
@@ -16,7 +15,7 @@ impl LogExporter for OtlpHttpClient {
             )
             .await?;
 
-        handle_partial_success(&response_body, self.protocol);
+        handle_partial_success(&response_body, self.encoding);
         Ok(())
     }
 
@@ -39,19 +38,27 @@ impl LogExporter for OtlpHttpClient {
 
 /// Handles partial success returned by OTLP endpoints. We log the rejected log records,
 /// as well as the error message returned.
-fn handle_partial_success(response_body: &[u8], protocol: Protocol) {
+fn handle_partial_success(response_body: &[u8], encoding: HttpEncoding) {
     use opentelemetry_proto::tonic::collector::logs::v1::ExportLogsServiceResponse;
 
-    let response: ExportLogsServiceResponse = match protocol {
+    let response: ExportLogsServiceResponse = match encoding {
         #[cfg(feature = "http-json")]
-        Protocol::HttpJson => match serde_json::from_slice(response_body) {
+        HttpEncoding::Json => match serde_json::from_slice(response_body) {
             Ok(r) => r,
             Err(e) => {
                 otel_debug!(name: "HttpLogsClient.ResponseParseError", error = e.to_string());
                 return;
             }
         },
-        _ => match Message::decode(response_body) {
+        HttpEncoding::Protobuf => match Message::decode(response_body) {
+            Ok(r) => r,
+            Err(e) => {
+                otel_debug!(name: "HttpLogsClient.ResponseParseError", error = e.to_string());
+                return;
+            }
+        },
+        #[cfg(not(feature = "http-json"))]
+        HttpEncoding::Json => match Message::decode(response_body) {
             Ok(r) => r,
             Err(e) => {
                 otel_debug!(name: "HttpLogsClient.ResponseParseError", error = e.to_string());
@@ -81,15 +88,15 @@ mod tests {
         let invalid = vec![0xFF, 0xFF, 0xFF, 0xFF];
 
         // Should not panic - logs debug and returns early
-        handle_partial_success(&invalid, Protocol::HttpBinary);
+        handle_partial_success(&invalid, HttpEncoding::Protobuf);
     }
 
     #[test]
     fn test_handle_empty_response() {
         let empty = vec![];
 
         // Should not panic
-        handle_partial_success(&empty, Protocol::HttpBinary);
+        handle_partial_success(&empty, HttpEncoding::Protobuf);
     }
 
     #[cfg(feature = "http-json")]
@@ -98,6 +105,6 @@ mod tests {
         let invalid_json = b"{not valid json}";
 
         // Should not panic - logs debug and returns
-        handle_partial_success(invalid_json, Protocol::HttpJson);
+        handle_partial_success(invalid_json, HttpEncoding::Json);
     }
 }

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

@@ -1,11 +1,10 @@
 use crate::metric::MetricsClient;
-use crate::Protocol;
 use opentelemetry::{otel_debug, otel_warn};
 use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
 use opentelemetry_sdk::metrics::data::ResourceMetrics;
 use prost::Message;
 
-use super::OtlpHttpClient;
+use super::{HttpEncoding, OtlpHttpClient};
 
 impl MetricsClient for OtlpHttpClient {
     async fn export(&self, metrics: &ResourceMetrics) -> OTelSdkResult {
@@ -19,7 +18,7 @@ impl MetricsClient for OtlpHttpClient {
             .export_http_with_retry(metrics, build_body_wrapper, "HttpMetricsClient.Export")
             .await?;
 
-        handle_partial_success(&response_body, self.protocol);
+        handle_partial_success(&response_body, self.encoding);
         Ok(())
     }
 
@@ -35,19 +34,27 @@ impl MetricsClient for OtlpHttpClient {
 
 /// Handles partial success returned by OTLP endpoints. We log the rejected data points,
 /// as well as the error message returned.
-fn handle_partial_success(response_body: &[u8], protocol: Protocol) {
+fn handle_partial_success(response_body: &[u8], encoding: HttpEncoding) {
     use opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceResponse;
 
-    let response: ExportMetricsServiceResponse = match protocol {
+    let response: ExportMetricsServiceResponse = match encoding {
         #[cfg(feature = "http-json")]
-        Protocol::HttpJson => match serde_json::from_slice(response_body) {
+        HttpEncoding::Json => match serde_json::from_slice(response_body) {
             Ok(r) => r,
             Err(e) => {
                 otel_debug!(name: "HttpMetricsClient.ResponseParseError", error = e.to_string());
                 return;
             }
         },
-        _ => match Message::decode(response_body) {
+        HttpEncoding::Protobuf => match Message::decode(response_body) {
+            Ok(r) => r,
+            Err(e) => {
+                otel_debug!(name: "HttpMetricsClient.ResponseParseError", error = e.to_string());
+                return;
+            }
+        },
+        #[cfg(not(feature = "http-json"))]
+        HttpEncoding::Json => match Message::decode(response_body) {
             Ok(r) => r,
             Err(e) => {
                 otel_debug!(name: "HttpMetricsClient.ResponseParseError", error = e.to_string());
@@ -77,15 +84,15 @@ mod tests {
         let invalid = vec![0xFF, 0xFF, 0xFF, 0xFF];
 
         // Should not panic - logs debug and returns early
-        handle_partial_success(&invalid, Protocol::HttpBinary);
+        handle_partial_success(&invalid, HttpEncoding::Protobuf);
     }
 
     #[test]
     fn test_handle_empty_response() {
         let empty = vec![];
 
         // Should not panic
-        handle_partial_success(&empty, Protocol::HttpBinary);
+        handle_partial_success(&empty, HttpEncoding::Protobuf);
     }
 
     #[cfg(feature = "http-json")]
@@ -94,6 +101,6 @@ mod tests {
         let invalid_json = b"{not valid json}";
 
         // Should not panic - logs debug and returns
-        handle_partial_success(invalid_json, Protocol::HttpJson);
+        handle_partial_success(invalid_json, HttpEncoding::Json);
     }
 }