Merge branch 'main' into fix-clear-baggage

cijothomas · web-flow · commit 9801db613ec5 · 2025-05-30T07:51:47.000-07:00
diff --git a/docs/release_0.30.md b/docs/release_0.30.md
@@ -0,0 +1,68 @@
+# Release Notes 0.30
+
+OpenTelemetry Rust 0.30 introduces a few breaking changes to the
+`opentelemetry_sdk` crate in the `metrics` feature. These changes were essential
+to drive the Metrics SDK towards stability. With this release, the Metrics SDK
+is officially declared stable. The Metrics API was declared stable last year,
+and previously, the Logs API, SDK, and OTel-Appender-Tracing were also marked
+stable. Importantly, no breaking changes have been introduced to components
+already marked as stable.
+
+It is worth noting that the `opentelemetry-otlp` crate remains in a
+Release-Candidate state and is not yet considered stable. With the API and SDK
+for Logs and Metrics now stable, the focus will shift towards further refining
+and stabilizing the OTLP Exporters in upcoming releases. Additionally,
+Distributed Tracing is expected to progress towards stability, addressing key
+interoperability challenges.
+
+For detailed changelogs of individual crates, please refer to their respective
+changelog files. This document serves as a summary of the main changes.
+
+## Key Changes
+
+### Metrics SDK Improvements
+
+1. **Stabilized "view" features**: Previously under an experimental feature
+   flag, views can now be used to modify the name, unit, description, and
+   cardinality limit of a metric. Advanced view capabilities, such as changing
+   aggregation or dropping attributes, remain under the experimental feature
+   flag.
+
+2. **Cardinality capping**: Introduced the ability to cap cardinality and
+   configure limits using views.
+
+3. **Polished public API**: Refined the public API to hide implementation
+   details from exporters, enabling future internal optimizations and ensuring
+   consistency. Some APIs related to authoring custom metric readers have been
+   moved behind experimental feature flags. These advanced use cases require
+   more time to finalize the API surface before being included in the stable
+   release.
+
+### Context-Based Suppression
+
+Added the ability to suppress telemetry based on Context. This feature prevents
+telemetry-induced-telemetry scenarios and addresses a long-standing issue. Note
+that suppression relies on proper context propagation. Certain libraries used in
+OTLP Exporters utilize `tracing` but do not adopt OpenTelemetry's context
+propagation. As a result, not all telemetry is automatically suppressed with
+this feature. Improvements in this area are expected in future releases.
+
+## Next Release
+
+In the [next
+release](https://github.com/open-telemetry/opentelemetry-rust/milestone/22), the
+focus will shift to OTLP Exporters and Distributed Tracing, specifically
+resolving
+[interoperability](https://github.com/open-telemetry/opentelemetry-rust/issues/2420)
+issues with `tokio-tracing` and other fixes required to drive Distributed
+Tracing towards stability.
+
+## Acknowledgments
+
+Thank you to everyone who contributed to this milestone. We welcome your
+feedback through GitHub issues or discussions in the OTel-Rust Slack channel
+[here](https://cloud-native.slack.com/archives/C03GDP0H023).
+
+We are also excited to announce that [Anton Grübel](https://github.com/gruebel)
+and [Björn Antonsson](https://github.com/bantonsson) have joined the OTel Rust
+project as Approvers.
diff --git a/opentelemetry-otlp/src/exporter/http/logs.rs b/opentelemetry-otlp/src/exporter/http/logs.rs
@@ -30,20 +30,24 @@ impl LogExporter for OtlpHttpClient {
         }
 
         let request_uri = request.uri().to_string();
-        otel_debug!(name: "HttpLogsClient.CallingExport");
+        otel_debug!(name: "HttpLogsClient.ExportStarted");
         let response = client
             .send_bytes(request)
             .await
             .map_err(|e| OTelSdkError::InternalFailure(format!("{e:?}")))?;
+
         if !response.status().is_success() {
             let error = format!(
                 "OpenTelemetry logs export failed. Url: {}, Status Code: {}, Response: {:?}",
                 request_uri,
                 response.status().as_u16(),
                 response.body()
             );
+            otel_debug!(name: "HttpLogsClient.ExportFailed", error = &error);
             return Err(OTelSdkError::InternalFailure(error));
         }
+
+        otel_debug!(name: "HttpLogsClient.ExportSucceeded");
         Ok(())
     }
 
diff --git a/opentelemetry-otlp/src/exporter/http/metrics.rs b/opentelemetry-otlp/src/exporter/http/metrics.rs
@@ -33,13 +33,30 @@ impl MetricsClient for OtlpHttpClient {
             request.headers_mut().insert(k.clone(), v.clone());
         }
 
-        otel_debug!(name: "HttpMetricsClient.CallingExport");
-        client
-            .send_bytes(request)
-            .await
-            .map_err(|e| OTelSdkError::InternalFailure(format!("{e:?}")))?;
+        otel_debug!(name: "HttpMetricsClient.ExportStarted");
+        let result = client.send_bytes(request).await;
 
-        Ok(())
+        match result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    otel_debug!(name: "HttpMetricsClient.ExportSucceeded");
+                    Ok(())
+                } else {
+                    let error = format!(
+                        "OpenTelemetry metrics export failed. Status Code: {}, Response: {:?}",
+                        response.status().as_u16(),
+                        response.body()
+                    );
+                    otel_debug!(name: "HttpMetricsClient.ExportFailed", error = &error);
+                    Err(OTelSdkError::InternalFailure(error))
+                }
+            }
+            Err(e) => {
+                let error = format!("{e:?}");
+                otel_debug!(name: "HttpMetricsClient.ExportFailed", error = &error);
+                Err(OTelSdkError::InternalFailure(error))
+            }
+        }
     }
 
     fn shutdown(&self) -> OTelSdkResult {
diff --git a/opentelemetry-otlp/src/exporter/http/mod.rs b/opentelemetry-otlp/src/exporter/http/mod.rs
@@ -365,7 +365,7 @@ fn resolve_http_endpoint(
     provided_endpoint: Option<&str>,
 ) -> Result<Uri, ExporterBuildError> {
     // programmatic configuration overrides any value set via environment variables
-    if let Some(provider_endpoint) = provided_endpoint {
+    if let Some(provider_endpoint) = provided_endpoint.filter(|s| !s.is_empty()) {
         provider_endpoint
             .parse()
             .map_err(|er: http::uri::InvalidUri| {
@@ -528,6 +528,15 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_use_default_when_empty_string_for_option() {
+        run_env_test(vec![], || {
+            let endpoint =
+                super::resolve_http_endpoint("non_existent_var", "/v1/traces", Some("")).unwrap();
+            assert_eq!(endpoint, "http://localhost:4318/v1/traces");
+        });
+    }
+
     #[test]
     fn test_use_default_when_others_missing() {
         run_env_test(vec![], || {
diff --git a/opentelemetry-otlp/src/exporter/http/trace.rs b/opentelemetry-otlp/src/exporter/http/trace.rs
@@ -42,7 +42,7 @@ impl SpanExporter for OtlpHttpClient {
         }
 
         let request_uri = request.uri().to_string();
-        otel_debug!(name: "HttpTracesClient.CallingExport");
+        otel_debug!(name: "HttpTracesClient.ExportStarted");
         let response = client
             .send_bytes(request)
             .await
@@ -51,13 +51,15 @@ impl SpanExporter for OtlpHttpClient {
         if !response.status().is_success() {
             let error = format!(
                 "OpenTelemetry trace export failed. Url: {}, Status Code: {}, Response: {:?}",
-                response.status().as_u16(),
                 request_uri,
+                response.status().as_u16(),
                 response.body()
             );
+            otel_debug!(name: "HttpTracesClient.ExportFailed", error = &error);
             return Err(OTelSdkError::InternalFailure(error));
         }
 
+        otel_debug!(name: "HttpTracesClient.ExportSucceeded");
         Ok(())
     }
 
diff --git a/opentelemetry-otlp/src/exporter/tonic/logs.rs b/opentelemetry-otlp/src/exporter/tonic/logs.rs
@@ -72,17 +72,27 @@ impl LogExporter for TonicLogsClient {
 
         let resource_logs = group_logs_by_resource_and_scope(batch, &self.resource);
 
-        otel_debug!(name: "TonicsLogsClient.CallingExport");
+        otel_debug!(name: "TonicLogsClient.ExportStarted");
 
-        client
+        let result = client
             .export(Request::from_parts(
                 metadata,
                 extensions,
                 ExportLogsServiceRequest { resource_logs },
             ))
-            .await
-            .map_err(|e| OTelSdkError::InternalFailure(format!("export error: {:?}", e)))?;
-        Ok(())
+            .await;
+
+        match result {
+            Ok(_) => {
+                otel_debug!(name: "TonicLogsClient.ExportSucceeded");
+                Ok(())
+            }
+            Err(e) => {
+                let error = format!("export error: {:?}", e);
+                otel_debug!(name: "TonicLogsClient.ExportFailed", error = &error);
+                Err(OTelSdkError::InternalFailure(error))
+            }
+        }
     }
 
     fn shutdown_with_timeout(&self, _timeout: time::Duration) -> OTelSdkResult {
diff --git a/opentelemetry-otlp/src/exporter/tonic/metrics.rs b/opentelemetry-otlp/src/exporter/tonic/metrics.rs
@@ -75,18 +75,27 @@ impl MetricsClient for TonicMetricsClient {
                 )),
             })?;
 
-        otel_debug!(name: "TonicsMetricsClient.CallingExport");
+        otel_debug!(name: "TonicMetricsClient.ExportStarted");
 
-        client
+        let result = client
             .export(Request::from_parts(
                 metadata,
                 extensions,
                 ExportMetricsServiceRequest::from(metrics),
             ))
-            .await
-            .map_err(|e| OTelSdkError::InternalFailure(format!("{e:?}")))?;
+            .await;
 
-        Ok(())
+        match result {
+            Ok(_) => {
+                otel_debug!(name: "TonicMetricsClient.ExportSucceeded");
+                Ok(())
+            }
+            Err(e) => {
+                let error = format!("{e:?}");
+                otel_debug!(name: "TonicMetricsClient.ExportFailed", error = &error);
+                Err(OTelSdkError::InternalFailure(error))
+            }
+        }
     }
 
     fn shutdown(&self) -> OTelSdkResult {
diff --git a/opentelemetry-otlp/src/exporter/tonic/mod.rs b/opentelemetry-otlp/src/exporter/tonic/mod.rs
@@ -225,7 +225,7 @@ impl TonicExporterBuilder {
         // If users for some reason want to use a custom path, they can use env var or builder to pass it
         //
         // programmatic configuration overrides any value set via environment variables
-        if let Some(endpoint) = provided_endpoint {
+        if let Some(endpoint) = provided_endpoint.filter(|s| !s.is_empty()) {
             endpoint
         } else if let Ok(endpoint) = env::var(default_endpoint_var) {
             endpoint
@@ -666,4 +666,15 @@ mod tests {
             assert_eq!(url, "http://localhost:4317");
         });
     }
+
+    #[test]
+    fn test_use_default_when_empty_string_for_option() {
+        run_env_test(vec![], || {
+            let url = TonicExporterBuilder::resolve_endpoint(
+                OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
+                Some(String::new()),
+            );
+            assert_eq!(url, "http://localhost:4317");
+        });
+    }
 }
diff --git a/opentelemetry-otlp/src/exporter/tonic/trace.rs b/opentelemetry-otlp/src/exporter/tonic/trace.rs
@@ -76,17 +76,27 @@ impl SpanExporter for TonicTracesClient {
 
         let resource_spans = group_spans_by_resource_and_scope(batch, &self.resource);
 
-        otel_debug!(name: "TonicsTracesClient.CallingExport");
+        otel_debug!(name: "TonicTracesClient.ExportStarted");
 
-        client
+        let result = client
             .export(Request::from_parts(
                 metadata,
                 extensions,
                 ExportTraceServiceRequest { resource_spans },
             ))
-            .await
-            .map_err(|e| OTelSdkError::InternalFailure(e.to_string()))?;
-        Ok(())
+            .await;
+
+        match result {
+            Ok(_) => {
+                otel_debug!(name: "TonicTracesClient.ExportSucceeded");
+                Ok(())
+            }
+            Err(e) => {
+                let error = e.to_string();
+                otel_debug!(name: "TonicTracesClient.ExportFailed", error = &error);
+                Err(OTelSdkError::InternalFailure(error))
+            }
+        }
     }
 
     fn shutdown(&mut self) -> OTelSdkResult {
diff --git a/opentelemetry-sdk/CHANGELOG.md b/opentelemetry-sdk/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 ## vNext
 
+- TODO: Placeholder for Span processor related things
+  - *Fix* SpanProcessor::on_start is no longer called on non recording spans
+
 ## 0.30.0
 
 Released 2025-May-23
diff --git a/opentelemetry-sdk/src/trace/tracer.rs b/opentelemetry-sdk/src/trace/tracer.rs
@@ -13,7 +13,10 @@ use crate::trace::{
     IdGenerator, ShouldSample, SpanEvents, SpanLimits, SpanLinks,
 };
 use opentelemetry::{
-    trace::{SamplingDecision, SpanBuilder, SpanContext, SpanKind, TraceContextExt, TraceFlags},
+    trace::{
+        SamplingDecision, Span as _, SpanBuilder, SpanContext, SpanKind, TraceContextExt,
+        TraceFlags,
+    },
     Context, InstrumentationScope, KeyValue,
 };
 use std::fmt;
@@ -281,9 +284,11 @@ impl opentelemetry::trace::Tracer for SdkTracer {
             }
         };
 
-        // Call `on_start` for all processors
-        for processor in provider.span_processors() {
-            processor.on_start(&mut span, parent_cx)
+        if span.is_recording() {
+            // Call `on_start` for all processors
+            for processor in provider.span_processors() {
+                processor.on_start(&mut span, parent_cx)
+            }
         }
 
         span
