feat: replace OtlpPipeline with exporter builders

Author: pitoniak32

examples/tracing-jaeger/src/main.rs

@@ -4,27 +4,26 @@ use opentelemetry::{
     trace::{TraceContextExt, TraceError, Tracer},
     KeyValue,
 };
-use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_sdk::trace::TracerProvider;
 use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};
 use opentelemetry_semantic_conventions::resource::SERVICE_NAME;
 
 use std::error::Error;
 
 fn init_tracer_provider() -> Result<opentelemetry_sdk::trace::TracerProvider, TraceError> {
-    opentelemetry_otlp::new_pipeline()
-        .tracing()
-        .with_exporter(
-            opentelemetry_otlp::new_exporter()
-                .tonic()
-                .with_endpoint("http://localhost:4317"),
-        )
-        .with_trace_config(
+    let exporter = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .build()?;
+
+    Ok(TracerProvider::builder()
+        .with_batch_exporter(exporter, runtime::Tokio)
+        .with_config(
             sdktrace::Config::default().with_resource(Resource::new(vec![KeyValue::new(
                 SERVICE_NAME,
                 "tracing-jaeger",
             )])),
         )
-        .install_batch(runtime::Tokio)
+        .build())
 }
 
 #[tokio::main]

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

@@ -8,8 +8,9 @@ use opentelemetry::{
     KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::{ExportConfig, WithExportConfig};
-use opentelemetry_sdk::trace::Config;
+use opentelemetry_otlp::{ExportConfig, LogExporter, MetricsExporter, SpanExporter};
+use opentelemetry_sdk::logs::LoggerProvider;
+use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};
 use std::error::Error;
 use tracing::info;
@@ -24,43 +25,31 @@ static RESOURCE: Lazy<Resource> = Lazy::new(|| {
 });
 
 fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
-    opentelemetry_otlp::new_pipeline()
-        .tracing()
-        .with_exporter(
-            opentelemetry_otlp::new_exporter()
-                .tonic()
-                .with_endpoint("http://localhost:4317"),
-        )
-        .with_trace_config(Config::default().with_resource(RESOURCE.clone()))
-        .install_batch(runtime::Tokio)
+    let b = SpanExporter::builder().with_tonic().build()?;
+    Ok(sdktrace::TracerProvider::builder()
+        .with_batch_exporter(b, runtime::Tokio)
+        .build())
 }
 
 fn init_metrics() -> Result<opentelemetry_sdk::metrics::SdkMeterProvider, MetricsError> {
     let export_config = ExportConfig {
         endpoint: "http://localhost:4317".to_string(),
         ..ExportConfig::default()
     };
-    opentelemetry_otlp::new_pipeline()
-        .metrics(runtime::Tokio)
-        .with_exporter(
-            opentelemetry_otlp::new_exporter()
-                .tonic()
-                .with_export_config(export_config),
-        )
-        .with_resource(RESOURCE.clone())
-        .build()
+
+    let exporter = MetricsExporter::builder().with_tonic().build()?;
+
+    let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
+
+    Ok(SdkMeterProvider::builder().with_reader(reader).build())
 }
 
 fn init_logs() -> Result<opentelemetry_sdk::logs::LoggerProvider, LogError> {
-    opentelemetry_otlp::new_pipeline()
-        .logging()
-        .with_resource(RESOURCE.clone())
-        .with_exporter(
-            opentelemetry_otlp::new_exporter()
-                .tonic()
-                .with_endpoint("http://localhost:4317"),
-        )
-        .install_batch(runtime::Tokio)
+    let exporter = LogExporter::builder().with_tonic().build()?;
+
+    Ok(LoggerProvider::builder()
+        .with_batch_exporter(exporter, runtime::Tokio)
+        .build())
 }
 
 #[tokio::main]

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

@@ -409,8 +409,7 @@ fn add_header_from_string(input: &str, headers: &mut HashMap<HeaderName, HeaderV
 mod tests {
     use crate::exporter::tests::run_env_test;
     use crate::{
-        new_exporter, WithExportConfig, OTEL_EXPORTER_OTLP_ENDPOINT,
-        OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
+        HttpExporterBuilder, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
     };
 
     use super::{build_endpoint_uri, resolve_http_endpoint};
@@ -618,7 +617,7 @@ mod tests {
     fn test_http_exporter_endpoint() {
         // default endpoint should add signal path
         run_env_test(vec![], || {
-            let exporter = new_exporter().http();
+            let exporter = HttpExporterBuilder::default();
 
             let url = resolve_http_endpoint(
                 OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
@@ -632,9 +631,7 @@ mod tests {
 
         // if builder endpoint is set, it should not add signal path
         run_env_test(vec![], || {
-            let exporter = new_exporter()
-                .http()
-                .with_endpoint("http://localhost:4318/v1/tracesbutnotreally");
+            let exporter = HttpExporterBuilder::default();
 
             let url = resolve_http_endpoint(
                 OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,

opentelemetry-otlp/src/exporter/mod.rs

@@ -291,15 +291,15 @@ mod tests {
     #[cfg(any(feature = "http-proto", feature = "http-json"))]
     #[test]
     fn test_default_http_endpoint() {
-        let exporter_builder = crate::new_exporter().http();
+        let exporter_builder = crate::HttpExporterBuilder::default();
 
         assert_eq!(exporter_builder.exporter_config.endpoint, "");
     }
 
     #[cfg(feature = "grpc-tonic")]
     #[test]
     fn test_default_tonic_endpoint() {
-        let exporter_builder = crate::new_exporter().tonic();
+        let exporter_builder = crate::TonicExporterBuilder::default();
 
         assert_eq!(exporter_builder.exporter_config.endpoint, "");
     }

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

@@ -25,7 +25,7 @@ mod logs;
 mod metrics;
 
 #[cfg(feature = "trace")]
-mod trace;
+pub(crate) mod trace;
 
 /// Configuration for [tonic]
 ///

opentelemetry-otlp/src/lib.rs

@@ -225,23 +225,21 @@ pub use crate::exporter::Compression;
 pub use crate::exporter::ExportConfig;
 #[cfg(feature = "trace")]
 pub use crate::span::{
-    OtlpTracePipeline, SpanExporter, SpanExporterBuilder, OTEL_EXPORTER_OTLP_TRACES_COMPRESSION,
+    SpanExporter, SpanExporterBuilder, OTEL_EXPORTER_OTLP_TRACES_COMPRESSION,
     OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_HEADERS,
     OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
 };
 
 #[cfg(feature = "metrics")]
 pub use crate::metric::{
-    MetricsExporter, MetricsExporterBuilder, OtlpMetricPipeline,
-    OTEL_EXPORTER_OTLP_METRICS_COMPRESSION, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    MetricsExporter, OTEL_EXPORTER_OTLP_METRICS_COMPRESSION, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
     OTEL_EXPORTER_OTLP_METRICS_HEADERS, OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
 };
 
 #[cfg(feature = "logs")]
 pub use crate::logs::{
-    LogExporter, LogExporterBuilder, OtlpLogPipeline, OTEL_EXPORTER_OTLP_LOGS_COMPRESSION,
-    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT, OTEL_EXPORTER_OTLP_LOGS_HEADERS,
-    OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+    LogExporter, OTEL_EXPORTER_OTLP_LOGS_COMPRESSION, OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+    OTEL_EXPORTER_OTLP_LOGS_HEADERS, OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
 };
 
 pub use crate::exporter::{
@@ -253,6 +251,38 @@ pub use crate::exporter::{
 
 use opentelemetry_sdk::export::ExportError;
 
+/// OTLP span exporter builder.
+#[derive(Debug)]
+// This enum only used during initialization stage of application. The overhead should be OK.
+// Users can also disable the unused features to make the overhead on object size smaller.
+#[allow(clippy::large_enum_variant)]
+#[non_exhaustive]
+pub enum ExporterOption {
+    /// Tonic span exporter builder
+    #[cfg(feature = "grpc-tonic")]
+    Tonic(TonicExporterBuilder),
+    /// Http span exporter builder
+    #[cfg(any(feature = "http-proto", feature = "http-json"))]
+    Http(HttpExporterBuilder),
+    /// Missing exporter builder
+    #[doc(hidden)]
+    #[cfg(not(any(feature = "http-proto", feature = "grpc-tonic")))]
+    Unconfigured,
+}
+
+impl Default for ExporterOption {
+    fn default() -> Self {
+        #[cfg(feature = "grpc-tonic")]
+        ExporterOption::Tonic(TonicExporterBuilder::default())
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct NoExporterBuilder;
+
+#[derive(Debug, Default)]
+pub struct ExporterBuilder(ExporterOption);
+
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
 pub use crate::exporter::http::HttpExporterBuilder;
 
@@ -262,55 +292,6 @@ pub use crate::exporter::tonic::{TonicConfig, TonicExporterBuilder};
 #[cfg(feature = "serialize")]
 use serde::{Deserialize, Serialize};
 
-/// General builder for both tracing and metrics.
-#[derive(Debug)]
-pub struct OtlpPipeline;
-
-/// Build a OTLP metrics or tracing exporter builder. See functions below to understand
-/// what's currently supported.
-#[derive(Debug)]
-pub struct OtlpExporterPipeline;
-
-impl OtlpExporterPipeline {
-    /// Use tonic as grpc layer, return a `TonicExporterBuilder` to config tonic and build the exporter.
-    ///
-    /// This exporter can be used in both `tracing` and `metrics` pipeline.
-    #[cfg(feature = "grpc-tonic")]
-    pub fn tonic(self) -> TonicExporterBuilder {
-        TonicExporterBuilder::default()
-    }
-
-    /// Use HTTP as transport layer, return a `HttpExporterBuilder` to config the http transport
-    /// and build the exporter.
-    ///
-    /// This exporter can be used in both `tracing` and `metrics` pipeline.
-    #[cfg(any(feature = "http-proto", feature = "http-json"))]
-    pub fn http(self) -> HttpExporterBuilder {
-        HttpExporterBuilder::default()
-    }
-}
-
-/// Create a new pipeline builder with the recommended configuration.
-///
-/// ## Examples
-///
-/// ```no_run
-/// fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-///     # #[cfg(feature = "trace")]
-///     let tracing_builder = opentelemetry_otlp::new_pipeline().tracing();
-///
-///     Ok(())
-/// }
-/// ```
-pub fn new_pipeline() -> OtlpPipeline {
-    OtlpPipeline
-}
-
-/// Create a builder to build OTLP metrics exporter or tracing exporter.
-pub fn new_exporter() -> OtlpExporterPipeline {
-    OtlpExporterPipeline
-}
-
 /// Wrap type for errors from this crate.
 #[derive(thiserror::Error, Debug)]
 pub enum Error {