test: fix and enable doctests (#2730)

Author: gruebel

opentelemetry-appender-log/src/lib.rs

@@ -12,12 +12,12 @@
 //!
 //! ```
 //! # #[tokio::main] async fn main() {
-//! # use opentelemetry_sdk::logs::{BatchLogProcessor, LoggerProvider};
+//! # use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
 //! # use opentelemetry_sdk::runtime;
 //! let exporter = opentelemetry_stdout::LogExporter::default();
 //!
-//! let logger_provider = LoggerProvider::builder()
-//!     .with_log_processor(BatchLogProcessor::builder(exporter, runtime::Tokio).build())
+//! let logger_provider = SdkLoggerProvider::builder()
+//!     .with_log_processor(BatchLogProcessor::builder(exporter).build())
 //!     .build();
 //! # }
 //! ```
@@ -26,12 +26,12 @@
 //!
 //! ```
 //! # #[tokio::main] async fn main() {
-//! # use opentelemetry_sdk::logs::{BatchLogProcessor, LoggerProvider};
+//! # use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
 //! # use opentelemetry_sdk::runtime;
 //! # use opentelemetry_appender_log::OpenTelemetryLogBridge;
 //! # let exporter = opentelemetry_stdout::LogExporter::default();
-//! # let logger_provider = LoggerProvider::builder()
-//! #     .with_log_processor(BatchLogProcessor::builder(exporter, runtime::Tokio).build())
+//! # let logger_provider = SdkLoggerProvider::builder()
+//! #     .with_log_processor(BatchLogProcessor::builder(exporter).build())
 //! #     .build();
 //! let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
 //!

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

@@ -57,12 +57,12 @@ pub struct HttpConfig {
 ///
 /// ## Examples
 ///
-/// ```
+/// ```no_run
 /// # #[cfg(feature="metrics")]
 /// use opentelemetry_sdk::metrics::Temporality;
 ///
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// // Create a span exporter you can use to when configuring tracer providers
+/// // Create a span exporter you can use when configuring tracer providers
 /// # #[cfg(feature="trace")]
 /// let span_exporter = opentelemetry_otlp::SpanExporter::builder().with_http().build()?;
 ///

opentelemetry-sdk/src/lib.rs

@@ -20,7 +20,7 @@
 //!     let exporter = new_exporter();
 //!
 //!     // Create a new trace pipeline that prints to stdout
-//!     let provider = TracerProvider::builder()
+//!     let provider = SdkTracerProvider::builder()
 //!         .with_simple_exporter(exporter)
 //!         .build();
 //!     let tracer = provider.tracer("readme_example");

opentelemetry-sdk/src/logs/batch_log_processor.rs

@@ -107,7 +107,7 @@ type LogsData = Box<(SdkLogRecord, InstrumentationScope)>;
 /// ### Using a BatchLogProcessor:
 ///
 /// ```rust
-/// use opentelemetry_sdk::logs::{BatchLogProcessor, BatchConfigBuilder, LoggerProvider};
+/// use opentelemetry_sdk::logs::{BatchLogProcessor, BatchConfigBuilder, SdkLoggerProvider};
 /// use opentelemetry::global;
 /// use std::time::Duration;
 /// use opentelemetry_sdk::logs::InMemoryLogExporter;
@@ -123,7 +123,7 @@ type LogsData = Box<(SdkLogRecord, InstrumentationScope)>;
 ///     )
 ///     .build();
 ///
-/// let provider = LoggerProvider::builder()
+/// let provider = SdkLoggerProvider::builder()
 ///     .with_log_processor(processor)
 ///     .build();
 ///

opentelemetry-sdk/src/logs/in_memory_exporter.rs

@@ -17,7 +17,7 @@ type LogResult<T> = Result<T, OTelSdkError>;
 ///
 /// # Example
 /// ```no_run
-///# use opentelemetry_sdk::logs::{BatchLogProcessor, LoggerProvider};
+///# use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
 ///# use opentelemetry_sdk::runtime;
 ///# use opentelemetry_sdk::logs::InMemoryLogExporter;
 ///
@@ -26,7 +26,7 @@ type LogResult<T> = Result<T, OTelSdkError>;
 ///    // Create an InMemoryLogExporter
 ///    let exporter: InMemoryLogExporter = InMemoryLogExporter::default();
 ///    //Create a LoggerProvider and register the exporter
-///    let logger_provider = LoggerProvider::builder()
+///    let logger_provider = SdkLoggerProvider::builder()
 ///        .with_log_processor(BatchLogProcessor::builder(exporter.clone()).build())
 ///        .build();
 ///    // Setup Log Appenders and emit logs. (Not shown here)
@@ -78,15 +78,15 @@ pub struct LogDataWithResource {
 ///
 /// ```no_run
 ///# use opentelemetry_sdk::logs::{InMemoryLogExporter, InMemoryLogExporterBuilder};
-///# use opentelemetry_sdk::logs::{BatchLogProcessor, LoggerProvider};
+///# use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
 ///# use opentelemetry_sdk::runtime;
 ///
 ///# #[tokio::main]
 ///# async fn main() {
 ///    //Create an InMemoryLogExporter
 ///    let exporter: InMemoryLogExporter = InMemoryLogExporterBuilder::default().build();
 ///    //Create a LoggerProvider and register the exporter
-///    let logger_provider = LoggerProvider::builder()
+///    let logger_provider = SdkLoggerProvider::builder()
 ///        .with_log_processor(BatchLogProcessor::builder(exporter.clone()).build())
 ///        .build();
 ///    // Setup Log Appenders and emit logs. (Not shown here)

opentelemetry-sdk/src/logs/simple_log_processor.rs

@@ -47,12 +47,12 @@ use std::sync::Mutex;
 /// ### Using a SimpleLogProcessor
 ///
 /// ```rust
-/// use opentelemetry_sdk::logs::{SimpleLogProcessor, LoggerProvider, LogExporter};
+/// use opentelemetry_sdk::logs::{SimpleLogProcessor, SdkLoggerProvider, LogExporter};
 /// use opentelemetry::global;
 /// use opentelemetry_sdk::logs::InMemoryLogExporter;
 ///
 /// let exporter = InMemoryLogExporter::default(); // Replace with an actual exporter
-/// let provider = LoggerProvider::builder()
+/// let provider = SdkLoggerProvider::builder()
 ///     .with_simple_exporter(exporter)
 ///     .build();
 ///

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -16,12 +16,12 @@ use std::sync::{Arc, Mutex};
 ///# use opentelemetry_sdk::propagation::TraceContextPropagator;
 ///# use opentelemetry_sdk::runtime;
 ///# use opentelemetry_sdk::trace::InMemorySpanExporterBuilder;
-///# use opentelemetry_sdk::trace::{BatchSpanProcessor, TracerProvider};
+///# use opentelemetry_sdk::trace::{BatchSpanProcessor, SdkTracerProvider};
 ///
 ///# #[tokio::main]
 ///# async fn main() {
 ///     let exporter = InMemorySpanExporterBuilder::new().build();
-///     let provider = TracerProvider::builder()
+///     let provider = SdkTracerProvider::builder()
 ///         .with_span_processor(BatchSpanProcessor::builder(exporter.clone()).build())
 ///         .build();
 ///
@@ -37,11 +37,8 @@ use std::sync::{Arc, Mutex};
 ///     cx.span().add_event("handling this...", Vec::new());
 ///     cx.span().end();
 ///
-///     let results = provider.force_flush();
-///     for result in results {
-///         if let Err(e) = result {
-///             println!("{:?}", e)
-///         }
+///     if let Err(e) = provider.force_flush() {
+///         println!("{:?}", e)
 ///     }
 ///     let spans = exporter.get_finished_spans().unwrap();
 ///     for span in spans {

opentelemetry-sdk/src/trace/provider.rs

@@ -39,8 +39,8 @@ use crate::error::{OTelSdkError, OTelSdkResult};
 /// use opentelemetry_sdk::trace::SdkTracerProvider;
 /// use opentelemetry::trace::Tracer;
 ///
-/// fn init_tracing() -> TracerProvider {
-///     let provider = TracerProvider::default();
+/// fn init_tracing() -> SdkTracerProvider {
+///     let provider = SdkTracerProvider::default();
 ///
 ///     // Set the provider to be used globally
 ///     let _ = global::set_tracer_provider(provider.clone());
@@ -198,8 +198,8 @@ impl SdkTracerProvider {
     /// use opentelemetry::global;
     /// use opentelemetry_sdk::trace::SdkTracerProvider;
     ///
-    /// fn init_tracing() -> TracerProvider {
-    ///     let provider = TracerProvider::default();
+    /// fn init_tracing() -> SdkTracerProvider {
+    ///     let provider = SdkTracerProvider::default();
     ///
     ///     // Set provider to be used as global tracer provider
     ///     let _ = global::set_tracer_provider(provider.clone());
@@ -213,10 +213,8 @@ impl SdkTracerProvider {
     ///     // create spans..
     ///
     ///     // force all spans to flush
-    ///     for result in provider.force_flush() {
-    ///         if let Err(err) = result {
-    ///             // .. handle flush error
-    ///         }
+    ///     if let Err(err) = provider.force_flush() {
+    ///         // .. handle flush error
     ///     }
     ///
     ///     // create more spans..

opentelemetry-sdk/src/trace/span_processor.rs

@@ -193,7 +193,7 @@ impl<T: SpanExporter> SpanProcessor for SimpleSpanProcessor<T> {
 /// ```rust
 /// use opentelemetry::global;
 /// use opentelemetry_sdk::{
-///     trace::{BatchSpanProcessor, BatchConfigBuilder, TracerProvider},
+///     trace::{BatchSpanProcessor, BatchConfigBuilder, SdkTracerProvider},
 ///     runtime,
 ///     testing::trace::NoopSpanExporter,
 /// };
@@ -217,7 +217,7 @@ impl<T: SpanExporter> SpanProcessor for SimpleSpanProcessor<T> {
 ///         .build();
 ///
 ///     // Step 3: Set up a TracerProvider with the configured processor.
-///     let provider = TracerProvider::builder()
+///     let provider = SdkTracerProvider::builder()
 ///         .with_span_processor(batch_processor)
 ///         .build();
 ///     global::set_tracer_provider(provider.clone());

opentelemetry-sdk/src/trace/span_processor_with_async_runtime.rs

@@ -68,7 +68,7 @@ use std::sync::Arc;
 ///         .build();
 ///
 ///     // Then use the `with_batch_exporter` method to have the provider export spans in batches.
-///     let provider = trace::TracerProvider::builder()
+///     let provider = trace::SdkTracerProvider::builder()
 ///         .with_span_processor(batch)
 ///         .build();
 ///