feat: force user to add exporter builder pipeline. (#1272)

feat: force user to add exporter builder pipeline.

Currently, when users don't configure a builder pipeline. We will throw a runtime error.

This change force user to call `with_exporter` before building exporters or installing pipeline and eliminate the `NoExporterBuilder` error

Author: TommyCpp

opentelemetry-otlp/CHANGELOG.md

@@ -12,6 +12,7 @@
 - Bump MSRV to 1.64 [#1203](https://github.com/open-telemetry/opentelemetry-rust/pull/1203)
 - Changed dependency from `opentelemetry_api` to `opentelemetry` as the latter
   is now the API crate. [#1226](https://github.com/open-telemetry/opentelemetry-rust/pull/1226)
+- Make `NoExporterBuilder` a compiling time error [#1271](https://github.com/open-telemetry/opentelemetry-rust/pull/1271)
 
 ## v0.13.0
 

opentelemetry-otlp/src/lib.rs

@@ -366,10 +366,6 @@ pub enum Error {
     #[error("the lock of the {0} has been poisoned")]
     PoisonedLock(&'static str),
 
-    /// The pipeline will need a exporter to complete setup. Throw this error if none is provided.
-    #[error("no exporter builder is provided, please provide one using with_exporter() method")]
-    NoExporterBuilder,
-
     /// Unsupported compression algorithm.
     #[error("unsupported compression algorithm '{0}'")]
     UnsupportedCompressionAlgorithm(String),
@@ -408,3 +404,8 @@ pub enum Protocol {
     /// HTTP protocol with binary protobuf
     HttpBinary,
 }
+
+#[derive(Debug, Default)]
+#[doc(hidden)]
+/// Placeholder type when no exporter pipeline has been configured in telemetry pipeline.
+pub struct NoExporterConfig(());

opentelemetry-otlp/src/logs.rs

@@ -11,7 +11,7 @@ use crate::exporter::grpcio::GrpcioExporterBuilder;
 #[cfg(feature = "http-proto")]
 use crate::exporter::http::HttpExporterBuilder;
 
-use crate::OtlpPipeline;
+use crate::{NoExporterConfig, OtlpPipeline};
 use async_trait::async_trait;
 use std::{borrow::Cow, fmt::Debug};
 
@@ -32,8 +32,11 @@ pub const OTEL_EXPORTER_OTLP_LOGS_TIMEOUT: &str = "OTEL_EXPORTER_OTLP_LOGS_TIMEO
 
 impl OtlpPipeline {
     /// Create a OTLP logging pipeline.
-    pub fn logging(self) -> OtlpLogPipeline {
-        OtlpLogPipeline::default()
+    pub fn logging(self) -> OtlpLogPipeline<NoExporterConfig> {
+        OtlpLogPipeline {
+            log_config: None,
+            exporter_builder: NoExporterConfig(()),
+        }
     }
 }
 
@@ -51,11 +54,6 @@ pub enum LogExporterBuilder {
     /// Http log exporter builder
     #[cfg(feature = "http-proto")]
     Http(HttpExporterBuilder),
-
-    /// Missing exporter builder
-    #[doc(hidden)]
-    #[cfg(not(any(feature = "http-proto", feature = "grpc-sys", feature = "grpc-tonic")))]
-    Unconfigured,
 }
 
 impl LogExporterBuilder {
@@ -68,10 +66,6 @@ impl LogExporterBuilder {
             LogExporterBuilder::Grpcio(builder) => builder.build_log_exporter(),
             #[cfg(feature = "http-proto")]
             LogExporterBuilder::Http(builder) => builder.build_log_exporter(),
-            #[cfg(not(any(feature = "http-proto", feature = "grpc-sys", feature = "grpc-tonic")))]
-            LogExporterBuilder::Unconfigured => {
-                Err(LogError::Other("no configured span exporter".into()))
-            }
         }
     }
 }
@@ -120,35 +114,42 @@ impl opentelemetry_sdk::export::logs::LogExporter for LogExporter {
 }
 
 /// Recommended configuration for an OTLP exporter pipeline.
-#[derive(Default, Debug)]
-pub struct OtlpLogPipeline {
-    exporter_builder: Option<LogExporterBuilder>,
+#[derive(Debug)]
+pub struct OtlpLogPipeline<EB> {
+    exporter_builder: EB,
     log_config: Option<opentelemetry_sdk::logs::Config>,
 }
 
-impl OtlpLogPipeline {
-    /// Set the OTLP log exporter builder.
-    pub fn with_exporter<B: Into<LogExporterBuilder>>(mut self, pipeline: B) -> Self {
-        self.exporter_builder = Some(pipeline.into());
-        self
-    }
-
+impl<EB> OtlpLogPipeline<EB> {
     /// Set the log provider configuration.
     pub fn with_log_config(mut self, log_config: opentelemetry_sdk::logs::Config) -> Self {
         self.log_config = Some(log_config);
         self
     }
+}
+
+impl OtlpLogPipeline<NoExporterConfig> {
+    /// Set the OTLP log exporter builder.
+    pub fn with_exporter<B: Into<LogExporterBuilder>>(
+        self,
+        pipeline: B,
+    ) -> OtlpLogPipeline<LogExporterBuilder> {
+        OtlpLogPipeline {
+            exporter_builder: pipeline.into(),
+            log_config: self.log_config,
+        }
+    }
+}
 
+impl OtlpLogPipeline<LogExporterBuilder> {
     /// Install the configured log exporter.
     ///
     /// Returns a [`Logger`] with the name `opentelemetry-otlp` and the current crate version.
     ///
     /// [`Logger`]: opentelemetry_sdk::logs::Logger
     pub fn install_simple(self) -> Result<opentelemetry_sdk::logs::Logger, LogError> {
         Ok(build_simple_with_exporter(
-            self.exporter_builder
-                .ok_or(crate::Error::NoExporterBuilder)?
-                .build_log_exporter()?,
+            self.exporter_builder.build_log_exporter()?,
             self.log_config,
         ))
     }
@@ -164,9 +165,7 @@ impl OtlpLogPipeline {
         runtime: R,
     ) -> Result<opentelemetry_sdk::logs::Logger, LogError> {
         Ok(build_batch_with_exporter(
-            self.exporter_builder
-                .ok_or(crate::Error::NoExporterBuilder)?
-                .build_log_exporter()?,
+            self.exporter_builder.build_log_exporter()?,
             self.log_config,
             runtime,
         ))

opentelemetry-otlp/src/metric.rs

@@ -3,7 +3,7 @@
 //! Defines a [MetricsExporter] to send metric data to backend via OTEL protocol.
 //!
 
-use crate::{Error, OtlpPipeline};
+use crate::{NoExporterConfig, OtlpPipeline};
 use async_trait::async_trait;
 use core::fmt;
 use opentelemetry::{global, metrics::Result};
@@ -42,15 +42,15 @@ pub const OTEL_EXPORTER_OTLP_METRICS_TIMEOUT: &str = "OTEL_EXPORTER_OTLP_METRICS
 pub const OTEL_EXPORTER_OTLP_METRICS_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_METRICS_COMPRESSION";
 impl OtlpPipeline {
     /// Create a OTLP metrics pipeline.
-    pub fn metrics<RT>(self, rt: RT) -> OtlpMetricPipeline<RT>
+    pub fn metrics<RT>(self, rt: RT) -> OtlpMetricPipeline<RT, NoExporterConfig>
     where
         RT: Runtime,
     {
         OtlpMetricPipeline {
             rt,
             aggregator_selector: None,
             temporality_selector: None,
-            exporter_pipeline: None,
+            exporter_pipeline: NoExporterConfig(()),
             resource: None,
             period: None,
             timeout: None,
@@ -129,17 +129,17 @@ impl From<HttpExporterBuilder> for MetricsExporterBuilder {
 ///
 /// Note that currently the OTLP metrics exporter only supports tonic as it's grpc layer and tokio as
 /// runtime.
-pub struct OtlpMetricPipeline<RT> {
+pub struct OtlpMetricPipeline<RT, EB> {
     rt: RT,
     aggregator_selector: Option<Box<dyn AggregationSelector>>,
     temporality_selector: Option<Box<dyn TemporalitySelector>>,
-    exporter_pipeline: Option<MetricsExporterBuilder>,
+    exporter_pipeline: EB,
     resource: Option<Resource>,
     period: Option<time::Duration>,
     timeout: Option<time::Duration>,
 }
 
-impl<RT> OtlpMetricPipeline<RT>
+impl<RT, EB> OtlpMetricPipeline<RT, EB>
 where
     RT: Runtime,
 {
@@ -151,14 +151,6 @@ where
         }
     }
 
-    /// Build with the exporter
-    pub fn with_exporter<B: Into<MetricsExporterBuilder>>(self, pipeline: B) -> Self {
-        OtlpMetricPipeline {
-            exporter_pipeline: Some(pipeline.into()),
-            ..self
-        }
-    }
-
     /// Build with timeout
     pub fn with_timeout(self, timeout: time::Duration) -> Self {
         OtlpMetricPipeline {
@@ -190,18 +182,41 @@ where
             ..self
         }
     }
+}
+
+impl<RT> OtlpMetricPipeline<RT, NoExporterConfig>
+where
+    RT: Runtime,
+{
+    /// Build with the exporter
+    pub fn with_exporter<B: Into<MetricsExporterBuilder>>(
+        self,
+        pipeline: B,
+    ) -> OtlpMetricPipeline<RT, MetricsExporterBuilder> {
+        OtlpMetricPipeline {
+            exporter_pipeline: pipeline.into(),
+            rt: self.rt,
+            aggregator_selector: self.aggregator_selector,
+            temporality_selector: self.temporality_selector,
+            resource: self.resource,
+            period: self.period,
+            timeout: self.timeout,
+        }
+    }
+}
 
+impl<RT> OtlpMetricPipeline<RT, MetricsExporterBuilder>
+where
+    RT: Runtime,
+{
     /// Build MeterProvider
     pub fn build(self) -> Result<MeterProvider> {
-        let exporter = self
-            .exporter_pipeline
-            .ok_or(Error::NoExporterBuilder)?
-            .build_metrics_exporter(
-                self.temporality_selector
-                    .unwrap_or_else(|| Box::new(DefaultTemporalitySelector::new())),
-                self.aggregator_selector
-                    .unwrap_or_else(|| Box::new(DefaultAggregationSelector::new())),
-            )?;
+        let exporter = self.exporter_pipeline.build_metrics_exporter(
+            self.temporality_selector
+                .unwrap_or_else(|| Box::new(DefaultTemporalitySelector::new())),
+            self.aggregator_selector
+                .unwrap_or_else(|| Box::new(DefaultAggregationSelector::new())),
+        )?;
 
         let mut builder = PeriodicReader::builder(exporter, self.rt);
 
@@ -228,7 +243,7 @@ where
     }
 }
 
-impl<RT> fmt::Debug for OtlpMetricPipeline<RT> {
+impl<RT, EB: Debug> Debug for OtlpMetricPipeline<RT, EB> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("OtlpMetricPipeline")
             .field("exporter_pipeline", &self.exporter_pipeline)

opentelemetry-otlp/src/span.rs

@@ -26,7 +26,7 @@ use crate::exporter::grpcio::GrpcioExporterBuilder;
 #[cfg(feature = "http-proto")]
 use crate::exporter::http::HttpExporterBuilder;
 
-use crate::OtlpPipeline;
+use crate::{NoExporterConfig, OtlpPipeline};
 
 /// Target to which the exporter is going to send spans, defaults to https://localhost:4317/v1/traces.
 /// Learn about the relationship between this constant and default/metrics/logs at
@@ -39,8 +39,12 @@ pub const OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_TRAC
 
 impl OtlpPipeline {
     /// Create a OTLP tracing pipeline.
-    pub fn tracing(self) -> OtlpTracePipeline {
-        OtlpTracePipeline::default()
+    pub fn tracing(self) -> OtlpTracePipeline<NoExporterConfig> {
+        OtlpTracePipeline {
+            exporter_builder: NoExporterConfig(()),
+            trace_config: None,
+            batch_config: None,
+        }
     }
 }
 
@@ -51,14 +55,14 @@ impl OtlpPipeline {
 /// ```no_run
 /// let tracing_pipeline = opentelemetry_otlp::new_pipeline().tracing();
 /// ```
-#[derive(Default, Debug)]
-pub struct OtlpTracePipeline {
-    exporter_builder: Option<SpanExporterBuilder>,
+#[derive(Debug)]
+pub struct OtlpTracePipeline<EB> {
+    exporter_builder: EB,
     trace_config: Option<sdk::trace::Config>,
     batch_config: Option<sdk::trace::BatchConfig>,
 }
 
-impl OtlpTracePipeline {
+impl<EB> OtlpTracePipeline<EB> {
     /// Set the trace provider configuration.
     pub fn with_trace_config(mut self, trace_config: sdk::trace::Config) -> Self {
         self.trace_config = Some(trace_config);
@@ -70,29 +74,37 @@ impl OtlpTracePipeline {
         self.batch_config = Some(batch_config);
         self
     }
+}
 
+impl OtlpTracePipeline<NoExporterConfig> {
     /// Set the OTLP span exporter builder.
     ///
     /// Note that the pipeline will not build the exporter until [`install_batch`] or [`install_simple`]
     /// is called.
     ///
     /// [`install_batch`]: OtlpTracePipeline::install_batch
     /// [`install_simple`]: OtlpTracePipeline::install_simple
-    pub fn with_exporter<B: Into<SpanExporterBuilder>>(mut self, pipeline: B) -> Self {
-        self.exporter_builder = Some(pipeline.into());
-        self
+    pub fn with_exporter<B: Into<SpanExporterBuilder>>(
+        self,
+        pipeline: B,
+    ) -> OtlpTracePipeline<SpanExporterBuilder> {
+        OtlpTracePipeline {
+            exporter_builder: pipeline.into(),
+            trace_config: self.trace_config,
+            batch_config: self.batch_config,
+        }
     }
+}
 
+impl OtlpTracePipeline<SpanExporterBuilder> {
     /// Install the configured span exporter.
     ///
     /// Returns a [`Tracer`] with the name `opentelemetry-otlp` and current crate version.
     ///
     /// [`Tracer`]: opentelemetry::trace::Tracer
     pub fn install_simple(self) -> Result<sdk::trace::Tracer, TraceError> {
         Ok(build_simple_with_exporter(
-            self.exporter_builder
-                .ok_or(crate::Error::NoExporterBuilder)?
-                .build_span_exporter()?,
+            self.exporter_builder.build_span_exporter()?,
             self.trace_config,
         ))
     }
@@ -110,9 +122,7 @@ impl OtlpTracePipeline {
         runtime: R,
     ) -> Result<sdk::trace::Tracer, TraceError> {
         Ok(build_batch_with_exporter(
-            self.exporter_builder
-                .ok_or(crate::Error::NoExporterBuilder)?
-                .build_span_exporter()?,
+            self.exporter_builder.build_span_exporter()?,
             self.trace_config,
             runtime,
             self.batch_config,
@@ -181,11 +191,6 @@ pub enum SpanExporterBuilder {
     /// Http span exporter builder
     #[cfg(feature = "http-proto")]
     Http(HttpExporterBuilder),
-
-    /// Missing exporter builder
-    #[doc(hidden)]
-    #[cfg(not(any(feature = "http-proto", feature = "grpc-sys", feature = "grpc-tonic")))]
-    Unconfigured,
 }
 
 impl SpanExporterBuilder {
@@ -198,10 +203,6 @@ impl SpanExporterBuilder {
             SpanExporterBuilder::Grpcio(builder) => builder.build_span_exporter(),
             #[cfg(feature = "http-proto")]
             SpanExporterBuilder::Http(builder) => builder.build_span_exporter(),
-            #[cfg(not(any(feature = "http-proto", feature = "grpc-sys", feature = "grpc-tonic")))]
-            SpanExporterBuilder::Unconfigured => {
-                Err(TraceError::Other("no configured span exporter".into()))
-            }
         }
     }
 }

opentelemetry-sdk/src/metrics/meter.rs

@@ -60,7 +60,7 @@ impl Meter {
         let view_cache = Default::default();
 
         Meter {
-            scope: scope.clone(),
+            scope,
             pipes: Arc::clone(&pipes),
             u64_resolver: Resolver::new(Arc::clone(&pipes), Arc::clone(&view_cache)),
             i64_resolver: Resolver::new(Arc::clone(&pipes), Arc::clone(&view_cache)),