Merge branch 'main' into cijothomas/tracingd

Author: cijothomas

README.md

@@ -181,7 +181,6 @@ you're more than welcome to participate!
 
 * [Cijo Thomas](https://github.com/cijothomas)
 * [Harold Dost](https://github.com/hdost)
-* [Julian Tescher](https://github.com/jtescher)
 * [Lalit Kumar Bhasin](https://github.com/lalitb)
 * [Utkarsh Umesan Pillai](https://github.com/utpilla)
 * [Zhongyang Wu](https://github.com/TommyCpp)
@@ -195,6 +194,7 @@ you're more than welcome to participate!
 
 * [Dirkjan Ochtman](https://github.com/djc)
 * [Jan Kühle](https://github.com/frigus02)
+* [Julian Tescher](https://github.com/jtescher)
 * [Isobel Redelmeier](https://github.com/iredelmeier)
 * [Mike Goldsmith](https://github.com/MikeGoldsmith)
 

examples/tracing-jaeger/Cargo.toml

@@ -164,9 +164,27 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
 
     info!(target: "my-target", "hello from {}. My price is {}", "apple", 1.99);
 
-    tracer_provider.shutdown()?;
-    meter_provider.shutdown()?;
-    logger_provider.shutdown()?;
+    // Collect all shutdown errors
+    let mut shutdown_errors = Vec::new();
+    if let Err(e) = tracer_provider.shutdown() {
+        shutdown_errors.push(format!("tracer provider: {}", e));
+    }
+
+    if let Err(e) = meter_provider.shutdown() {
+        shutdown_errors.push(format!("meter provider: {}", e));
+    }
 
+    if let Err(e) = logger_provider.shutdown() {
+        shutdown_errors.push(format!("logger provider: {}", e));
+    }
+
+    // Return an error if any shutdown failed
+    if !shutdown_errors.is_empty() {
+        return Err(format!(
+            "Failed to shutdown providers:{}",
+            shutdown_errors.join("\n")
+        )
+        .into());
+    }
     Ok(())
 }

examples/tracing-jaeger/README.md

@@ -156,9 +156,29 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     });
 
     info!(name: "my-event", target: "my-target", "hello from {}. My price is {}", "apple", 1.99);
-    tracer_provider.shutdown()?;
-    meter_provider.shutdown()?;
-    logger_provider.shutdown()?;
+
+    // Collect all shutdown errors
+    let mut shutdown_errors = Vec::new();
+    if let Err(e) = tracer_provider.shutdown() {
+        shutdown_errors.push(format!("tracer provider: {}", e));
+    }
+
+    if let Err(e) = meter_provider.shutdown() {
+        shutdown_errors.push(format!("meter provider: {}", e));
+    }
+
+    if let Err(e) = logger_provider.shutdown() {
+        shutdown_errors.push(format!("logger provider: {}", e));
+    }
+
+    // Return an error if any shutdown failed
+    if !shutdown_errors.is_empty() {
+        return Err(format!(
+            "Failed to shutdown providers:{}",
+            shutdown_errors.join("\n")
+        )
+        .into());
+    }
 
     Ok(())
 }

examples/tracing-jaeger/jaeger.png

@@ -342,6 +342,7 @@ mod tests {
     #[cfg(feature = "logs")]
     #[cfg(any(feature = "http-proto", feature = "http-json"))]
     #[test]
+    #[ignore = "Unstable due to interference from env variable tests. Re-enable after https://github.com/open-telemetry/opentelemetry-rust/issues/2818 is resolved."]
     fn export_builder_error_invalid_http_endpoint() {
         use std::time::Duration;
 
@@ -358,15 +359,20 @@ mod tests {
             .with_export_config(ex_config)
             .build();
 
-        assert!(matches!(
-            exporter_result,
-            Err(crate::exporter::ExporterBuildError::InvalidUri(_, _))
-        ));
+        assert!(
+            matches!(
+                exporter_result,
+                Err(crate::exporter::ExporterBuildError::InvalidUri(_, _))
+            ),
+            "Expected InvalidUri error, but got {:?}",
+            exporter_result
+        );
     }
 
     #[cfg(feature = "grpc-tonic")]
-    #[test]
-    fn export_builder_error_invalid_grpc_endpoint() {
+    #[tokio::test]
+    #[ignore = "Unstable due to interference from env variable tests. Re-enable after https://github.com/open-telemetry/opentelemetry-rust/issues/2818 is resolved."]
+    async fn export_builder_error_invalid_grpc_endpoint() {
         use std::time::Duration;
 
         use crate::{ExportConfig, LogExporter, Protocol, WithExportConfig};

examples/tracing-jaeger/src/main.rs

@@ -1,33 +1,68 @@
-//! The OTLP Exporter supports exporting logs, metrics and traces in the OTLP
-//! format to the OpenTelemetry collector or other compatible backend.
+//! # OpenTelemetry OTLP Exporter
 //!
-//! The OpenTelemetry Collector offers a vendor-agnostic implementation on how
-//! to receive, process, and export telemetry data. In addition, it removes
-//! the need to run, operate, and maintain multiple agents/collectors in
-//! order to support open-source telemetry data formats (e.g. Jaeger,
-//! Prometheus, etc.) sending to multiple open-source or commercial back-ends.
+//! The OTLP Exporter enables exporting telemetry data (logs, metrics, and traces) in the
+//! OpenTelemetry Protocol (OTLP) format to compatible backends. These backends include:
 //!
-//! Currently, this crate supports sending telemetry in OTLP
-//! via gRPC and http (binary and json).
+//! - OpenTelemetry Collector
+//! - Open-source observability tools (Prometheus, Jaeger, etc.)
+//! - Vendor-specific monitoring platforms
 //!
-//! # Quickstart
+//! This crate supports sending OTLP data via:
+//! - gRPC
+//! - HTTP (binary protobuf or JSON)
 //!
-//! First make sure you have a running version of the opentelemetry collector
-//! you want to send data to:
+//! ## Quickstart with OpenTelemetry Collector
+//!
+//! ### HTTP Transport (Port 4318)
+//!
+//! Run the OpenTelemetry Collector:
 //!
 //! ```shell
-//! $ docker run -p 4317:4317 otel/opentelemetry-collector:latest
+//! $ docker run -p 4318:4318 otel/opentelemetry-collector:latest
+//! ```
+//!
+//! Configure your application to export traces via HTTP:
+//!
+//! ```no_run
+//! # #[cfg(all(feature = "trace", feature = "http-proto"))]
+//! # {
+//! use opentelemetry::global;
+//! use opentelemetry::trace::Tracer;
+//! use opentelemetry_otlp::Protocol;
+//! use opentelemetry_otlp::WithExportConfig;
+//!
+//! fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+//!     // Initialize OTLP exporter using HTTP binary protocol
+//!     let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
+//!         .with_http()
+//!         .with_protocol(Protocol::HttpBinary)
+//!         .build()?;
+//!
+//!     // Create a tracer provider with the exporter
+//!     let _ = opentelemetry_sdk::trace::SdkTracerProvider::builder()
+//!         .with_simple_exporter(otlp_exporter)
+//!         .build();
+//!
+//!     // Get a tracer and create spans
+//!     let tracer = global::tracer("my_tracer");
+//!     tracer.in_span("doing_work", |_cx| {
+//!         // Your application logic here...
+//!     });
+//!
+//!     Ok(())
+//! # }
+//! }
 //! ```
 //!
-//! Then create a new `Exporter`, and `Provider` with the recommended defaults to start exporting
-//! telemetry.
+//! ### gRPC Transport (Port 4317)
+//!
+//! Run the OpenTelemetry Collector:
 //!
-//! You will have to build a OTLP exporter first. Create the correct exporter based on the signal
-//! you are looking to export `SpanExporter::builder()`, `MetricExporter::builder()`,
-//! `LogExporter::builder()` respectively for traces, metrics, and logs.
+//! ```shell
+//! $ docker run -p 4317:4317 otel/opentelemetry-collector:latest
+//! ```
 //!
-//! Once you have the exporter, you can create your `Provider` by starting with `TracerProvider::builder()`,
-//! `SdkMeterProvider::builder()`, and `LoggerProvider::builder()` respectively for traces, metrics, and logs.
+//! Configure your application to export traces via gRPC:
 //!
 //! ```no_run
 //! # #[cfg(all(feature = "trace", feature = "grpc-tonic"))]
@@ -36,22 +71,41 @@
 //! use opentelemetry::trace::Tracer;
 //!
 //! fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-//!     // First, create a OTLP exporter builder. Configure it as you need.
-//!     let otlp_exporter = opentelemetry_otlp::SpanExporter::builder().with_tonic().build()?;
-//!     // Then pass it into provider builder
+//!     // Initialize OTLP exporter using gRPC (Tonic)
+//!     let otlp_exporter = opentelemetry_otlp::SpanExporter::builder()
+//!         .with_tonic()
+//!         .build()?;
+//!
+//!     // Create a tracer provider with the exporter
 //!     let _ = opentelemetry_sdk::trace::SdkTracerProvider::builder()
 //!         .with_simple_exporter(otlp_exporter)
 //!         .build();
+//!
+//!     // Get a tracer and create spans
 //!     let tracer = global::tracer("my_tracer");
-//!     tracer.in_span("doing_work", |cx| {
-//!         // Traced app logic here...
+//!     tracer.in_span("doing_work", |_cx| {
+//!         // Your application logic here...
 //!     });
 //!
 //!     Ok(())
-//!   # }
+//! # }
 //! }
 //! ```
 //!
+//! ## Using with Jaeger
+//!
+//! Jaeger natively supports the OTLP protocol, making it easy to send traces directly:
+//!
+//! ```shell
+//! $ docker run -p 16686:16686 -p 4317:4317 -e COLLECTOR_OTLP_ENABLED=true jaegertracing/all-in-one:latest
+//! ```
+//!
+//! After running your application configured with the OTLP exporter, view traces at:
+//! `http://localhost:16686`
+//!
+//! ## Using with Prometheus (TODO)
+//! ## Show Logs, Metrics too (TODO)
+//!
 //! ## Performance
 //!
 //! For optimal performance, a batch exporting processor is recommended as the simple

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

@@ -1,3 +1,14 @@
+//! Execution-scoped context propagation.
+//!
+//! The `context` module provides mechanisms for propagating values across API boundaries and between
+//! logically associated execution units. It enables cross-cutting concerns to access their data in-process
+//! using a shared context object.
+//!
+//! # Main Types
+//!
+//! - [`Context`]: An immutable, execution-scoped collection of values.
+//!
+
 use crate::otel_warn;
 #[cfg(feature = "trace")]
 use crate::trace::context::SynchronizedSpan;
@@ -9,6 +20,10 @@ use std::hash::{BuildHasherDefault, Hasher};
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+mod future_ext;
+
+pub use future_ext::FutureExt;
+
 thread_local! {
     static CURRENT_CONTEXT: RefCell<ContextStack> = RefCell::new(ContextStack::default());
 }
@@ -78,7 +93,7 @@ thread_local! {
 #[derive(Clone, Default)]
 pub struct Context {
     #[cfg(feature = "trace")]
-    pub(super) span: Option<Arc<SynchronizedSpan>>,
+    pub(crate) span: Option<Arc<SynchronizedSpan>>,
     entries: Option<Arc<EntryMap>>,
 }
 
@@ -314,15 +329,15 @@ impl Context {
     }
 
     #[cfg(feature = "trace")]
-    pub(super) fn current_with_synchronized_span(value: SynchronizedSpan) -> Self {
+    pub(crate) fn current_with_synchronized_span(value: SynchronizedSpan) -> Self {
         Context {
             span: Some(Arc::new(value)),
             entries: Context::map_current(|cx| cx.entries.clone()),
         }
     }
 
     #[cfg(feature = "trace")]
-    pub(super) fn with_synchronized_span(&self, value: SynchronizedSpan) -> Self {
+    pub(crate) fn with_synchronized_span(&self, value: SynchronizedSpan) -> Self {
         Context {
             span: Some(Arc::new(value)),
             entries: self.entries.clone(),