feat: replace OtlpPipeline with exporter builders

examples/self-diagnostics/src/main.rs

@@ -1,7 +1,8 @@
 use opentelemetry::global::{self, set_error_handler, Error as OtelError};
 use opentelemetry::KeyValue;
 use opentelemetry_appender_tracing::layer;
-use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_otlp::{LogExporter, MetricExporter, WithExporterConfig};
+use opentelemetry_sdk::metrics::PeriodicReader;
 use tracing_subscriber::filter::{EnvFilter, LevelFilter};
 use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
@@ -51,15 +52,16 @@ fn custom_error_handler(err: OtelError) {
 }
 
 fn init_logger_provider() -> opentelemetry_sdk::logs::LoggerProvider {
- let provider = opentelemetry_otlp::new_pipeline()
- .logging()
- .with_exporter(
- opentelemetry_otlp::new_exporter()
- .http()
- .with_endpoint("http://localhost:4318/v1/logs"),
- )
- .install_batch(opentelemetry_sdk::runtime::Tokio)
+ let exporter = LogExporter::builder()
+ .with_http()
+ .with_endpoint("http://localhost:4318/v1/logs")
+ .build()
  .unwrap();
+
+ let provider = opentelemetry_sdk::logs::LoggerProvider::builder()
+ .with_batch_exporter(exporter, opentelemetry_sdk::runtime::Tokio)
+ .build();
+
  let cloned_provider = provider.clone();
 
  // Add a tracing filter to filter events from crates used by opentelemetry-otlp.
@@ -107,16 +109,20 @@ fn init_logger_provider() -> opentelemetry_sdk::logs::LoggerProvider {
 }
 
 fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
- let provider = opentelemetry_otlp::new_pipeline()
- .metrics(opentelemetry_sdk::runtime::Tokio)
- .with_period(std::time::Duration::from_secs(1))
- .with_exporter(
- opentelemetry_otlp::new_exporter()
- .http()
- .with_endpoint("http://localhost:4318/v1/metrics"),
- )
+ let exporter = MetricExporter::builder()
+ .with_tonic()
+ .with_endpoint("http://localhost:4318/v1/metrics")
  .build()
  .unwrap();
+
+ let reader = PeriodicReader::builder(exporter, opentelemetry_sdk::runtime::Tokio)
+ .with_interval(std::time::Duration::from_secs(1))
+ .build();
+
+ let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
+ .with_reader(reader)
+ .build();
+
  let cloned_provider = provider.clone();
  global::set_meter_provider(cloned_provider);
  provider

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/Cargo.toml

@@ -51,6 +51,7 @@ opentelemetry_sdk = { features = ["trace", "rt-tokio", "testing"], path = "../op
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 futures-util = { workspace = true }
 temp-env = { workspace = true }
+pretty_assertions = "1.4.1"
 
 [features]
 # telemetry pillars and functions

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

@@ -6,9 +6,14 @@ use opentelemetry::{
  KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::Protocol;
-use opentelemetry_otlp::{HttpExporterBuilder, WithExportConfig};
-use opentelemetry_sdk::trace::{self as sdktrace, Config};
+use opentelemetry_otlp::WithExporterConfig;
+use opentelemetry_otlp::{LogExporter, MetricExporter, Protocol, SpanExporter};
+use opentelemetry_sdk::{
+ logs::LoggerProvider,
+ metrics::{PeriodicReader, SdkMeterProvider},
+ runtime,
+ trace::{self as sdktrace, TracerProvider},
+};
 use opentelemetry_sdk::{
  logs::{self as sdklogs},
  Resource,
@@ -18,6 +23,9 @@ use tracing::info;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::EnvFilter;
 
+#[cfg(feature = "hyper")]
+use opentelemetry_otlp::WithHttpConfig;
+
 #[cfg(feature = "hyper")]
 mod hyper;
 
@@ -28,47 +36,46 @@ static RESOURCE: Lazy<Resource> = Lazy::new(|| {
  )])
 });
 
-fn http_exporter() -> HttpExporterBuilder {
- let exporter = opentelemetry_otlp::new_exporter().http();
+fn init_logs() -> Result<sdklogs::LoggerProvider, opentelemetry::logs::LogError> {
+ let exporter_builder = LogExporter::builder()
+ .with_http()
+ .with_endpoint("http://localhost:4318/v1/logs")
+ .with_protocol(Protocol::HttpBinary);
+
  #[cfg(feature = "hyper")]
- let exporter = exporter.with_http_client(hyper::HyperClient::default());
- exporter
-}
+ let exporter_builder = exporter_builder.with_http_client(hyper::HyperClient::default());
 
-fn init_logs() -> Result<sdklogs::LoggerProvider, opentelemetry::logs::LogError> {
- opentelemetry_otlp::new_pipeline()
- .logging()
+ let exporter = exporter_builder.build()?;
+
+ Ok(LoggerProvider::builder()
+ .with_batch_exporter(exporter, runtime::Tokio)
  .with_resource(RESOURCE.clone())
- .with_exporter(
- http_exporter()
- .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
- .with_endpoint("http://localhost:4318/v1/logs"),
- )
- .install_batch(opentelemetry_sdk::runtime::Tokio)
+ .build())
 }
 
 fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
- opentelemetry_otlp::new_pipeline()
- .tracing()
- .with_exporter(
-  http_exporter()
-  .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
-  .with_endpoint("http://localhost:4318/v1/traces"),
- )
- .with_trace_config(Config::default().with_resource(RESOURCE.clone()))
- .install_batch(opentelemetry_sdk::runtime::Tokio)
+ let exporter = SpanExporter::builder()
+ .with_http()
+ .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
+ .with_endpoint("http://localhost:4318/v1/traces")
+ .build()?;
+ Ok(TracerProvider::builder()
+ .with_batch_exporter(exporter, runtime::Tokio)
+ .with_resource(RESOURCE.clone())
+ .build())
 }
 
 fn init_metrics() -> Result<opentelemetry_sdk::metrics::SdkMeterProvider, MetricsError> {
- opentelemetry_otlp::new_pipeline()
- .metrics(opentelemetry_sdk::runtime::Tokio)
- .with_exporter(
- http_exporter()
- .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
- .with_endpoint("http://localhost:4318/v1/metrics"),
- )
+ let exporter = MetricExporter::builder()
+ .with_http()
+ .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
+ .with_endpoint("http://localhost:4318/v1/metrics")
+ .build()?;
+
+ Ok(SdkMeterProvider::builder()
+ .with_reader(PeriodicReader::builder(exporter, runtime::Tokio).build())
  .with_resource(RESOURCE.clone())
- .build()
+ .build())
 }
 
 #[tokio::main]

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

@@ -8,7 +8,9 @@ use opentelemetry::{
  KeyValue,
 };
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
-use opentelemetry_otlp::{ExportConfig, WithExportConfig};
+use opentelemetry_otlp::{LogExporter, MetricExporter, SpanExporter, WithExporterConfig};
+use opentelemetry_sdk::logs::LoggerProvider;
+use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::trace::Config;
 use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};
 use std::error::Error;
@@ -24,43 +26,38 @@ 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 exporter = SpanExporter::builder()
+ .with_tonic()
+ .with_endpoint("0.0.0.0:4317")
+ .build()?;
+ Ok(sdktrace::TracerProvider::builder()
+ .with_config(Config::default().with_resource(RESOURCE.clone()))
+ .with_batch_exporter(exporter, 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),
- )
+ let exporter = MetricExporter::builder().with_tonic().build()?;
+
+ let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
+
+ Ok(SdkMeterProvider::builder()
+ .with_reader(reader)
  .with_resource(RESOURCE.clone())
- .build()
+ .build())
 }
 
 fn init_logs() -> Result<opentelemetry_sdk::logs::LoggerProvider, LogError> {
- opentelemetry_otlp::new_pipeline()
- .logging()
+ let exporter = LogExporter::builder()
+ .with_tonic()
+ .with_protocol(opentelemetry_otlp::Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
+ .with_endpoint("http://localhost:4318/v1/logs")
+ .build()?;
+
+ Ok(LoggerProvider::builder()
  .with_resource(RESOURCE.clone())
- .with_exporter(
- opentelemetry_otlp::new_exporter()
- .tonic()
- .with_endpoint("http://localhost:4317"),
- )
- .install_batch(runtime::Tokio)
+ .with_batch_exporter(exporter, runtime::Tokio)
+ .build())
 }
 
 #[tokio::main]

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

@@ -5,12 +5,12 @@ use http::{header::CONTENT_TYPE, Method};
 use opentelemetry::metrics::{MetricsError, Result};
 use opentelemetry_sdk::metrics::data::ResourceMetrics;
 
-use crate::{metric::MetricsClient, Error};
+use crate::{metric::MetricClient, Error};
 
 use super::OtlpHttpClient;
 
 #[async_trait]
-impl MetricsClient for OtlpHttpClient {
+impl MetricClient for OtlpHttpClient {
  async fn export(&self, metrics: &mut ResourceMetrics) -> Result<()> {
  let client = self
  .client