Merge branch 'main' into exp-hist-internal-log

Author: lalitb

examples/metrics-advanced/src/main.rs

@@ -77,7 +77,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         .f64_histogram("my_histogram")
         .with_unit("ms")
         .with_description("My histogram example description")
-        .init();
+        .build();
 
     // Record measurements using the histogram instrument.
     histogram.record(
@@ -91,7 +91,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     );
 
     // Example 2 - Drop unwanted attributes using view.
-    let counter = meter.u64_counter("my_counter").init();
+    let counter = meter.u64_counter("my_counter").build();
 
     // Record measurements using the Counter instrument.
     // Though we are passing 4 attributes here, only 1 will be used
@@ -115,7 +115,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         .f64_histogram("my_second_histogram")
         .with_unit("ms")
         .with_description("My histogram example description")
-        .init();
+        .build();
 
     // Record measurements using the histogram instrument.
     // The values recorded are in the range of 1.2 to 1.5, warranting

examples/metrics-basic/src/main.rs

@@ -31,7 +31,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let meter = global::meter("mylibraryname");
 
     // Create a Counter Instrument.
-    let counter = meter.u64_counter("my_counter").init();
+    let counter = meter.u64_counter("my_counter").build();
 
     // Record measurements using the Counter instrument.
     counter.add(
@@ -56,10 +56,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 ],
             )
         })
-        .init();
+        .build();
 
     // Create a UpCounter Instrument.
-    let updown_counter = meter.i64_up_down_counter("my_updown_counter").init();
+    let updown_counter = meter.i64_up_down_counter("my_updown_counter").build();
 
     // Record measurements using the UpCounter instrument.
     updown_counter.add(
@@ -84,7 +84,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 ],
             )
         })
-        .init();
+        .build();
 
     // Create a Histogram Instrument.
     let histogram = meter
@@ -93,7 +93,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         // Setting boundaries is optional. By default, the boundaries are set to
         // [0.0, 5.0, 10.0, 25.0, 50.0, 75.0, 100.0, 250.0, 500.0, 750.0, 1000.0, 2500.0, 5000.0, 7500.0, 10000.0]
         .with_boundaries(vec![0.0, 5.0, 10.0, 15.0, 20.0, 25.0])
-        .init();
+        .build();
 
     // Record measurements using the histogram instrument.
     histogram.record(
@@ -111,7 +111,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         .f64_gauge("my_gauge")
         .with_description("A gauge set to 1.0")
         .with_unit("myunit")
-        .init();
+        .build();
 
     gauge.record(
         1.0,
@@ -135,7 +135,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 ],
             )
         })
-        .init();
+        .build();
 
     // Metrics are exported by default every 30 seconds when using stdout exporter,
     // however shutting down the MeterProvider here instantly flushes

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, MetricsExporter, WithExportConfig};
+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 = MetricsExporter::builder()
+        .with_http()
+        .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
@@ -137,7 +143,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // Create a meter from the above MeterProvider.
     let meter = global::meter("example");
     // Create a Counter Instrument.
-    let counter = meter.u64_counter("my_counter").init();
+    let counter = meter.u64_counter("my_counter").build();
 
     // Record measurements with unique key-value pairs to exceed the cardinality limit
     // of 2000 and trigger error message

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/CHANGELOG.md

@@ -10,8 +10,8 @@ Released 2024-Sep-30
 - Update `opentelemetry-http` dependency version to 0.26
 - Update `opentelemetry-proto` dependency version to 0.26
 - Bump MSRV to 1.71.1 [2140](https://github.com/open-telemetry/opentelemetry-rust/pull/2140)
-- **BREAKING**: [#2217](https://github.com/open-telemetry/opentelemetry-rust/pull/2217)
-  - **Replaced**: The `MetricsExporterBuilder` interface is modified from `with_temporality_selector` to `with_temporality` example can be seen below:
+- **BREAKING**: 
+  - ([#2217](https://github.com/open-telemetry/opentelemetry-rust/pull/2217)) **Replaced**: The `MetricsExporterBuilder` interface is modified from `with_temporality_selector` to `with_temporality` example can be seen below:
     Previous Signature:
     ```rust
     MetricsExporterBuilder::default().with_temporality_selector(DeltaTemporalitySelector::new())
@@ -20,6 +20,34 @@ Released 2024-Sep-30
     ```rust
     MetricsExporterBuilder::default().with_temporality(Temporality::Delta)
     ```
+  - ([#2221](https://github.com/open-telemetry/opentelemetry-rust/pull/2221)) **Replaced**:
+    - The `opentelemetry_otlp::new_pipeline().{trace,logging,metrics}()` interface is now replaced with `{TracerProvider,SdkMeterProvider,LoggerProvider}::builder()`.
+    - The `opentelemetry_otlp::new_exporter()` interface is now replaced with `{SpanExporter,MetricsExporter,LogExporter}::builder()`.
+
+    Pull request [#2221](https://github.com/open-telemetry/opentelemetry-rust/pull/2221) has a detailed migration guide in the description. See example below,
+    and [basic-otlp](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-otlp/examples/basic-otlp/src/main.rs) for more details:
+
+    Previous Signature:
+    ```rust
+    let logger_provider: LoggerProvider = opentelemetry_otlp::new_pipeline()
+      .logging()
+      .with_exporter(
+          opentelemetry_otlp::new_exporter()
+              .tonic()
+              .with_endpoint("http://localhost:4317")
+      )
+      .install_batch(runtime::Tokio)?;
+    ```
+    Updated Signature:
+    ```rust
+    let logger_provider: LoggerProvider = LoggerProvider::builder()
+      .install_batch_exporter(
+          LogExporter::builder()
+              .with_tonic()
+              .with_endpoint("http://localhost:4317")
+              .build()?,
+      ).build();
+    ```
 
 ## v0.25.0
 

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::WithExportConfig;
+use opentelemetry_otlp::{LogExporter, MetricsExporter, Protocol, SpanExporter};
+use opentelemetry_sdk::{
+    logs::LoggerProvider,
+    metrics::{PeriodicReader, SdkMeterProvider},
+    runtime,
+    trace::{self as sdktrace, Config, 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_config(Config::default().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 = MetricsExporter::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]
@@ -136,7 +143,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         .u64_counter("test_counter")
         .with_description("a simple counter for demo purposes.")
         .with_unit("my_unit")
-        .init();
+        .build();
     for _ in 0..10 {
         counter.add(1, &[KeyValue::new("test_key", "test_value")]);
     }