chore(otlp): add environment variable parsing for default exporter feature selection

Author: scottgerring

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

@@ -1,5 +1,5 @@
 use super::{
-    default_headers, default_protocol, parse_header_string, resolve_timeout, ExporterBuildError,
+    default_headers, parse_header_string, resolve_timeout, ExporterBuildError,
     OTEL_EXPORTER_OTLP_HTTP_ENDPOINT_DEFAULT,
 };
 use crate::{ExportConfig, Protocol, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS};
@@ -155,7 +155,7 @@ impl Default for HttpExporterBuilder {
     fn default() -> Self {
         HttpExporterBuilder {
             exporter_config: ExportConfig {
-                protocol: default_protocol(),
+                protocol: Protocol::default(),
                 ..ExportConfig::default()
             },
             http_config: HttpConfig {

opentelemetry-otlp/src/exporter/mod.rs

@@ -29,6 +29,13 @@ pub const OTEL_EXPORTER_OTLP_PROTOCOL: &str = "OTEL_EXPORTER_OTLP_PROTOCOL";
 /// Compression algorithm to use, defaults to none.
 pub const OTEL_EXPORTER_OTLP_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_COMPRESSION";
 
+/// Protocol value for HTTP with protobuf encoding
+pub const OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF: &str = "http/protobuf";
+/// Protocol value for gRPC
+pub const OTEL_EXPORTER_OTLP_PROTOCOL_GRPC: &str = "grpc";
+/// Protocol value for HTTP with JSON encoding
+pub 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";
 /// Default max waiting time for the backend to process each signal batch.
@@ -66,7 +73,7 @@ pub struct ExportConfig {
 #[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
 impl Default for ExportConfig {
     fn default() -> Self {
-        let protocol = default_protocol();
+        let protocol = Protocol::default();
 
         Self {
             endpoint: None,
@@ -170,25 +177,34 @@ fn resolve_compression_from_env(
     }
 }
 
-/// Returns the default protocol based on enabled features.
+/// Returns the default protocol based on environment variable or enabled features.
 ///
 /// Priority order (first available wins):
-/// 1. http-json (if enabled)
-/// 2. http-proto (if enabled)
-/// 3. grpc-tonic (if enabled)
+/// 1. OTEL_EXPORTER_OTLP_PROTOCOL environment variable (if set and feature is enabled)
+/// 2. http-json (if enabled)
+/// 3. http-proto (if enabled)
+/// 4. grpc-tonic (if enabled)
 #[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
-fn default_protocol() -> Protocol {
-    #[cfg(feature = "http-json")]
-    return Protocol::HttpJson;
-
-    #[cfg(all(feature = "http-proto", not(feature = "http-json")))]
-    return Protocol::HttpBinary;
-
-    #[cfg(all(
-        feature = "grpc-tonic",
-        not(any(feature = "http-proto", feature = "http-json"))
-    ))]
-    return Protocol::Grpc;
+impl Default for Protocol {
+    fn default() -> Self {
+        // Check environment variable first
+        if let Some(protocol) = Protocol::from_env() {
+            return protocol;
+        }
+
+        // Fall back to feature-based defaults
+        #[cfg(feature = "http-json")]
+        return Protocol::HttpJson;
+
+        #[cfg(all(feature = "http-proto", not(feature = "http-json")))]
+        return Protocol::HttpBinary;
+
+        #[cfg(all(
+            feature = "grpc-tonic",
+            not(any(feature = "http-proto", feature = "http-json"))
+        ))]
+        return Protocol::Grpc;
+    }
 }
 
 /// default user-agent headers
@@ -451,21 +467,15 @@ mod tests {
             not(any(feature = "grpc-tonic", feature = "http-proto"))
         ))]
         {
-            assert_eq!(
-                crate::exporter::default_protocol(),
-                crate::Protocol::HttpJson
-            );
+            assert_eq!(crate::Protocol::default(), crate::Protocol::HttpJson);
         }
 
         #[cfg(all(
             feature = "http-proto",
             not(any(feature = "grpc-tonic", feature = "http-json"))
         ))]
         {
-            assert_eq!(
-                crate::exporter::default_protocol(),
-                crate::Protocol::HttpBinary
-            );
+            assert_eq!(crate::Protocol::default(), crate::Protocol::HttpBinary);
         }
 
         #[cfg(all(
@@ -477,6 +487,58 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_protocol_from_env() {
+        use crate::{Protocol, OTEL_EXPORTER_OTLP_PROTOCOL};
+
+        // Test with no env var set - should return None
+        temp_env::with_var_unset(OTEL_EXPORTER_OTLP_PROTOCOL, || {
+            assert_eq!(Protocol::from_env(), None);
+        });
+
+        // Test with grpc protocol
+        #[cfg(feature = "grpc-tonic")]
+        run_env_test(vec![(OTEL_EXPORTER_OTLP_PROTOCOL, "grpc")], || {
+            assert_eq!(Protocol::from_env(), Some(Protocol::Grpc));
+        });
+
+        // Test with http/protobuf protocol
+        #[cfg(feature = "http-proto")]
+        run_env_test(vec![(OTEL_EXPORTER_OTLP_PROTOCOL, "http/protobuf")], || {
+            assert_eq!(Protocol::from_env(), Some(Protocol::HttpBinary));
+        });
+
+        // Test with http/json protocol
+        #[cfg(feature = "http-json")]
+        run_env_test(vec![(OTEL_EXPORTER_OTLP_PROTOCOL, "http/json")], || {
+            assert_eq!(Protocol::from_env(), Some(Protocol::HttpJson));
+        });
+
+        // Test with invalid protocol - should return None
+        run_env_test(vec![(OTEL_EXPORTER_OTLP_PROTOCOL, "invalid")], || {
+            assert_eq!(Protocol::from_env(), None);
+        });
+    }
+
+    #[test]
+    fn test_default_protocol_respects_env() {
+        // Test that env var takes precedence over feature-based defaults
+        #[cfg(all(feature = "http-json", feature = "http-proto"))]
+        run_env_test(
+            vec![(crate::OTEL_EXPORTER_OTLP_PROTOCOL, "http/protobuf")],
+            || {
+                // Even though http-json would be the default, env var should override
+                assert_eq!(crate::Protocol::default(), crate::Protocol::HttpBinary);
+            },
+        );
+
+        #[cfg(all(feature = "grpc-tonic", feature = "http-json"))]
+        run_env_test(vec![(crate::OTEL_EXPORTER_OTLP_PROTOCOL, "grpc")], || {
+            // Even though http-json would be the default, env var should override
+            assert_eq!(crate::Protocol::default(), crate::Protocol::Grpc);
+        });
+    }
+
     #[test]
     fn test_url_decode() {
         let test_cases = vec![

opentelemetry-otlp/src/lib.rs

@@ -409,7 +409,9 @@ pub use crate::exporter::tonic::{HasTonicConfig, WithTonicConfig};
 pub use crate::exporter::{
     HasExportConfig, WithExportConfig, OTEL_EXPORTER_OTLP_COMPRESSION, OTEL_EXPORTER_OTLP_ENDPOINT,
     OTEL_EXPORTER_OTLP_ENDPOINT_DEFAULT, OTEL_EXPORTER_OTLP_HEADERS, OTEL_EXPORTER_OTLP_PROTOCOL,
-    OTEL_EXPORTER_OTLP_TIMEOUT, OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT,
+    OTEL_EXPORTER_OTLP_PROTOCOL_GRPC, OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON,
+    OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF, OTEL_EXPORTER_OTLP_TIMEOUT,
+    OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT,
 };
 
 #[cfg(feature = "experimental-http-retry")]
@@ -459,6 +461,36 @@ pub enum Protocol {
     HttpJson,
 }
 
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
+impl Protocol {
+    /// Attempts to parse a protocol from the `OTEL_EXPORTER_OTLP_PROTOCOL` environment variable.
+    ///
+    /// Returns `None` if:
+    /// - The environment variable is not set
+    /// - The value doesn't match a known protocol
+    /// - The specified protocol's feature is not enabled
+    pub fn from_env() -> Option<Self> {
+        #[cfg(feature = "grpc-tonic")]
+        use crate::exporter::OTEL_EXPORTER_OTLP_PROTOCOL_GRPC;
+        #[cfg(feature = "http-json")]
+        use crate::exporter::OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON;
+        #[cfg(feature = "http-proto")]
+        use crate::exporter::OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF;
+
+        let protocol = std::env::var(OTEL_EXPORTER_OTLP_PROTOCOL).ok()?;
+
+        match protocol.as_str() {
+            #[cfg(feature = "grpc-tonic")]
+            OTEL_EXPORTER_OTLP_PROTOCOL_GRPC => Some(Protocol::Grpc),
+            #[cfg(feature = "http-proto")]
+            OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_PROTOBUF => Some(Protocol::HttpBinary),
+            #[cfg(feature = "http-json")]
+            OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON => Some(Protocol::HttpJson),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 #[doc(hidden)]
 /// Placeholder type when no exporter pipeline has been configured in telemetry pipeline.