Merge branch 'main' into semconv_1.31_0

Author: lalitb

README.md

@@ -31,12 +31,12 @@ documentation.
 | Signal/Component      | Overall Status     |
 | --------------------  | ------------------ |
 | Context               | Beta               |
-| Baggage               | Beta               |
+| Baggage               | RC                 |
 | Propagators           | Beta               |
 | Logs-API              | Stable*            |
-| Logs-SDK              | RC                 |
+| Logs-SDK              | Stable              |
 | Logs-OTLP Exporter    | RC                 |
-| Logs-Appender-Tracing | RC                 |
+| Logs-Appender-Tracing | Stable             |
 | Metrics-API           | Stable             |
 | Metrics-SDK           | RC                 |
 | Metrics-OTLP Exporter | RC                 |

docs/migration_0.29.md

@@ -0,0 +1,92 @@
+# Migration Guide from 0.28 to 0.29
+
+OpenTelemetry Rust 0.29 introduces a few breaking changes. This guide aims to
+facilitate a smooth migration for common use cases involving the
+`opentelemetry`, `opentelemetry_sdk`, `opentelemetry-otlp`, and
+`opentelemetry-appender-tracing` crates. For a comprehensive list of changes,
+please refer to the detailed changelog for each crate. This document covers only
+the most common scenarios. Note that changes that only affect custom
+exporter/processor authors are not mentioned in this doc.
+
+OpenTelemetry Metrics API and Log-Bridge API were declared stable in 0.28, and have
+no breaking changes.
+
+## Baggage Changes
+
+The Baggage API has been redesigned to align with the OpenTelemetry
+specification. While the core API for interacting with Baggage remains the same,
+the accepted data types have changed. Baggage Keys now only allow strings (ASCII
+printable characters), and Baggage values are restricted to strings.
+
+For detailed changes, see the [changelog](../opentelemetry/CHANGELOG.md). With
+version 0.29, the Baggage API has reached "Release Candidate" status, meaning
+further breaking changes will be highly restricted.
+
+## Appender-Tracing Changes
+
+The `opentelemetry-appender-tracing` crate, which bridges `tracing` events to
+OpenTelemetry logs, has been updated to properly map `tracing` data types to the
+OpenTelemetry model. As of version 0.29, this crate is considered "Stable," and
+no further breaking changes will be made without a major version bump.
+
+## Configuration via Environment Variables
+
+The 0.29 release aligns OpenTelemetry Rust with the rest of the OpenTelemetry
+ecosystem by treating any code-based configuration as final (i.e., it cannot be
+overridden by environment variables). This policy was partially true before but
+is now applied consistently. If you prefer to configure your application via
+environment variables, avoid configuring it programmatically.
+
+## Discontinuing Dedicated Prometheus Exporter
+
+The `opentelemetry-prometheus` crate will be discontinued with the 0.29 release.
+Active development on this crate ceased a few months ago. Given that Prometheus
+now natively supports OTLP, and considering that the OpenTelemetry Rust project
+is still working towards a 1.0 release, we need to focus on essential components
+to maintain scope and ensure timely delivery.
+
+Prometheus interoperability remains a key goal for OpenTelemetry. However, the
+current `opentelemetry-prometheus` crate requires a major rewrite to eliminate
+dependencies on unmaintained crates. We may reintroduce a dedicated Prometheus
+exporter in the future once these issues are resolved.
+
+### Migration Guide
+
+For those using Prometheus as a backend, you can integrate with Prometheus using
+the following methods:
+
+1. Use the OTLP Exporter to push metrics directly to Prometheus.
+2. If you require a pull (scrape) model, push metrics to an OpenTelemetry
+   Collector using the OTLP Exporter, and configure Prometheus to scrape the
+   OpenTelemetry Collector.
+
+These alternatives ensure continued Prometheus integration while allowing us to
+focus on achieving a stable 1.0 release for OpenTelemetry Rust.
+
+## Next Release
+
+In the [next
+release](https://github.com/open-telemetry/opentelemetry-rust/milestone/21), we
+expect to stabilize the Metrics SDK and resolve the long-standing question of
+`tokio-tracing` vs. `opentelemetry tracing`, which is a prerequisite before
+stabilizing Distributed Tracing. Additionally, `Context` is also expected to be
+enhanced with the ability to suppress telemetry-induced-telemetry.
+
+## Instrumentation Libraries
+
+Unlike other OpenTelemetry language implementations, OpenTelemetry Rust historically did not
+maintain any instrumentations directly. This has recently changed with a
+[contribution](https://github.com/open-telemetry/opentelemetry-rust-contrib/pull/202)
+from one of the founding members of the OpenTelemetry Rust project to the
+contrib repository, providing an instrumentation library for
+[`actix-web`](https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/actix-web-opentelemetry).
+We expect that this instrumentation will serve as a reference implementation demonstrating best practices for
+creating OpenTelemetry instrumentations in Rust.
+
+We welcome additional contributions of instrumentation libraries to the contrib repository.
+
+## Thanks
+
+Thank you to everyone who contributed to this milestone. Please share your feedback
+through GitHub issues or join the discussion in the OTel-Rust Slack channel
+[here](https://cloud-native.slack.com/archives/C03GDP0H023).

opentelemetry-otlp/CHANGELOG.md

@@ -17,6 +17,7 @@
  `Error` which contained many variants unrelated to building an exporter, the
  new one returns specific variants applicable to building an exporter. Some
  variants might be applicable only on select features.
+ Also, now unused `Error` enum is removed.
 - **Breaking** `ExportConfig`'s `timeout` field is now optional(`Option<Duration>`)
 - **Breaking** Export configuration done via code is final. ENV variables cannot be used to override the code config.
   Do not use code based config, if there is desire to control the settings via ENV variables.

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

@@ -287,7 +287,7 @@ impl OtlpHttpClient {
     fn build_trace_export_body(
         &self,
         spans: Vec<SpanData>,
-    ) -> opentelemetry_sdk::trace::TraceResult<(Vec<u8>, &'static str)> {
+    ) -> Result<(Vec<u8>, &'static str), String> {
         use opentelemetry_proto::tonic::collector::trace::v1::ExportTraceServiceRequest;
         let resource_spans = group_spans_by_resource_and_scope(spans, &self.resource);
 
@@ -296,7 +296,7 @@ impl OtlpHttpClient {
             #[cfg(feature = "http-json")]
             Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
                 Ok(json) => Ok((json.into_bytes(), "application/json")),
-                Err(e) => Err(opentelemetry_sdk::trace::TraceError::from(e.to_string())),
+                Err(e) => Err(e.to_string()),
             },
             _ => Ok((req.encode_to_vec(), "application/x-protobuf")),
         }

opentelemetry-otlp/src/lib.rs

@@ -362,8 +362,6 @@ pub use crate::exporter::{
     OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT,
 };
 
-use opentelemetry_sdk::ExportError;
-
 /// Type to indicate the builder does not have a client set.
 #[derive(Debug, Default, Clone)]
 pub struct NoExporterBuilderSet;
@@ -391,104 +389,6 @@ pub use crate::exporter::tonic::{TonicConfig, TonicExporterBuilder};
 #[cfg(feature = "serialize")]
 use serde::{Deserialize, Serialize};
 
-/// Wrap type for errors from this crate.
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    /// Wrap error from [`tonic::transport::Error`]
-    #[cfg(feature = "grpc-tonic")]
-    #[error("transport error {0}")]
-    Transport(#[from] tonic::transport::Error),
-
-    /// Wrap the [`tonic::codegen::http::uri::InvalidUri`] error
-    #[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
-    #[error("invalid URI {0}")]
-    InvalidUri(#[from] http::uri::InvalidUri),
-
-    /// Wrap type for [`tonic::Status`]
-    #[cfg(feature = "grpc-tonic")]
-    #[error("the grpc server returns error ({code}): {message}")]
-    Status {
-        /// grpc status code
-        code: tonic::Code,
-        /// error message
-        message: String,
-    },
-
-    /// Http requests failed because no http client is provided.
-    #[cfg(any(feature = "http-proto", feature = "http-json"))]
-    #[error(
-        "no http client, you must select one from features or provide your own implementation"
-    )]
-    NoHttpClient,
-
-    /// Http requests failed.
-    #[cfg(any(feature = "http-proto", feature = "http-json"))]
-    #[error("http request failed with {0}")]
-    RequestFailed(#[from] opentelemetry_http::HttpError),
-
-    /// The provided value is invalid in HTTP headers.
-    #[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
-    #[error("http header value error {0}")]
-    InvalidHeaderValue(#[from] http::header::InvalidHeaderValue),
-
-    /// The provided name is invalid in HTTP headers.
-    #[cfg(any(feature = "grpc-tonic", feature = "http-proto", feature = "http-json"))]
-    #[error("http header name error {0}")]
-    InvalidHeaderName(#[from] http::header::InvalidHeaderName),
-
-    /// Prost encode failed
-    #[cfg(any(
-        feature = "http-proto",
-        all(feature = "http-json", not(feature = "trace"))
-    ))]
-    #[error("prost encoding error {0}")]
-    EncodeError(#[from] prost::EncodeError),
-
-    /// The lock in exporters has been poisoned.
-    #[cfg(feature = "metrics")]
-    #[error("the lock of the {0} has been poisoned")]
-    PoisonedLock(&'static str),
-
-    /// Unsupported compression algorithm.
-    #[error("unsupported compression algorithm '{0}'")]
-    UnsupportedCompressionAlgorithm(String),
-
-    /// Feature required to use the specified compression algorithm.
-    #[cfg(any(not(feature = "gzip-tonic"), not(feature = "zstd-tonic")))]
-    #[error("feature '{0}' is required to use the compression algorithm '{1}'")]
-    FeatureRequiredForCompressionAlgorithm(&'static str, Compression),
-}
-
-#[cfg(feature = "grpc-tonic")]
-impl From<tonic::Status> for Error {
-    fn from(status: tonic::Status) -> Error {
-        Error::Status {
-            code: status.code(),
-            message: {
-                if !status.message().is_empty() {
-                    let mut result = ", detailed error message: ".to_string() + status.message();
-                    if status.code() == tonic::Code::Unknown {
-                        let source = (&status as &dyn std::error::Error)
-                            .source()
-                            .map(|e| format!("{:?}", e));
-                        result.push(' ');
-                        result.push_str(source.unwrap_or_default().as_ref());
-                    }
-                    result
-                } else {
-                    String::new()
-                }
-            },
-        }
-    }
-}
-
-impl ExportError for Error {
-    fn exporter_name(&self) -> &'static str {
-        "otlp"
-    }
-}
-
 /// The communication protocol to use when exporting data.
 #[cfg_attr(feature = "serialize", derive(Deserialize, Serialize))]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]

opentelemetry-sdk/CHANGELOG.md

@@ -75,7 +75,10 @@
 - **Breaking** for custom `LogProcessor` authors: Changed `set_resource`
   to require mutable ref.
   `fn set_resource(&mut self, _resource: &Resource) {}`
-- **Breaking** Removed deprecated functions and methods related to `trace::Config` 
+- **Breaking**: InMemoryExporter's return type change.
+  - `TraceResult<Vec<SpanData>>` to `Result<Vec<SpanData>, InMemoryExporterError>`
+  - `MetricResult<Vec<ResourceMetrics>>` to `Result<Vec<ResourceMetrics>, InMemoryExporterError>`
+  - `LogResult<Vec<LogDataWithResource>>` to `Result<Vec<LogDataWithResource>, InMemoryExporterError>`
 
 ## 0.28.0
 

opentelemetry-sdk/src/lib.rs

@@ -146,3 +146,24 @@ pub use resource::Resource;
 
 pub mod error;
 pub use error::ExportError;
+
+#[cfg(any(feature = "testing", test))]
+#[derive(thiserror::Error, Debug)]
+/// Errors that can occur during when returning telemetry from InMemoryLogExporter
+pub enum InMemoryExporterError {
+    /// Operation failed due to an internal error.
+    ///
+    /// The error message is intended for logging purposes only and should not
+    /// be used to make programmatic decisions. It is implementation-specific
+    /// and subject to change without notice. Consumers of this error should not
+    /// rely on its content beyond logging.
+    #[error("Unable to obtain telemetry. Reason: {0}")]
+    InternalFailure(String),
+}
+
+#[cfg(any(feature = "testing", test))]
+impl<T> From<std::sync::PoisonError<T>> for InMemoryExporterError {
+    fn from(err: std::sync::PoisonError<T>) -> Self {
+        InMemoryExporterError::InternalFailure(format!("Mutex poison error: {}", err))
+    }
+}

opentelemetry-sdk/src/logs/in_memory_exporter.rs

@@ -1,14 +1,13 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::logs::SdkLogRecord;
 use crate::logs::{LogBatch, LogExporter};
+use crate::InMemoryExporterError;
 use crate::Resource;
 use opentelemetry::InstrumentationScope;
 use std::borrow::Cow;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
-type LogResult<T> = Result<T, OTelSdkError>;
-
 /// An in-memory logs exporter that stores logs data in memory..
 ///
 /// This exporter is useful for testing and debugging purposes.
@@ -157,14 +156,9 @@ impl InMemoryLogExporter {
     /// let emitted_logs = exporter.get_emitted_logs().unwrap();
     /// ```
     ///
-    pub fn get_emitted_logs(&self) -> LogResult<Vec<LogDataWithResource>> {
-        let logs_guard = self
-            .logs
-            .lock()
-            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to lock logs: {}", e)))?;
-        let resource_guard = self.resource.lock().map_err(|e| {
-            OTelSdkError::InternalFailure(format!("Failed to lock resource: {}", e))
-        })?;
+    pub fn get_emitted_logs(&self) -> Result<Vec<LogDataWithResource>, InMemoryExporterError> {
+        let logs_guard = self.logs.lock().map_err(InMemoryExporterError::from)?;
+        let resource_guard = self.resource.lock().map_err(InMemoryExporterError::from)?;
         let logs: Vec<LogDataWithResource> = logs_guard
             .iter()
             .map(|log_data| LogDataWithResource {

opentelemetry-sdk/src/metrics/in_memory_exporter.rs

@@ -2,9 +2,8 @@ use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::metrics::data::{self, Gauge, Sum};
 use crate::metrics::data::{Histogram, Metric, ResourceMetrics, ScopeMetrics};
 use crate::metrics::exporter::PushMetricExporter;
-use crate::metrics::MetricError;
-use crate::metrics::MetricResult;
 use crate::metrics::Temporality;
+use crate::InMemoryExporterError;
 use std::collections::VecDeque;
 use std::fmt;
 use std::sync::{Arc, Mutex};
@@ -143,11 +142,13 @@ impl InMemoryMetricExporter {
     /// let exporter = InMemoryMetricExporter::default();
     /// let finished_metrics = exporter.get_finished_metrics().unwrap();
     /// ```
-    pub fn get_finished_metrics(&self) -> MetricResult<Vec<ResourceMetrics>> {
-        self.metrics
+    pub fn get_finished_metrics(&self) -> Result<Vec<ResourceMetrics>, InMemoryExporterError> {
+        let metrics = self
+            .metrics
             .lock()
             .map(|metrics_guard| metrics_guard.iter().map(Self::clone_metrics).collect())
-            .map_err(MetricError::from)
+            .map_err(InMemoryExporterError::from)?;
+        Ok(metrics)
     }
 
     /// Clears the internal storage of finished metrics.

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -1,7 +1,7 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::resource::Resource;
-use crate::trace::error::{TraceError, TraceResult};
 use crate::trace::{SpanData, SpanExporter};
+use crate::InMemoryExporterError;
 use std::sync::{Arc, Mutex};
 
 /// An in-memory span exporter that stores span data in memory.
@@ -104,11 +104,13 @@ impl InMemorySpanExporter {
     /// let exporter = InMemorySpanExporter::default();
     /// let finished_spans = exporter.get_finished_spans().unwrap();
     /// ```
-    pub fn get_finished_spans(&self) -> TraceResult<Vec<SpanData>> {
-        self.spans
+    pub fn get_finished_spans(&self) -> Result<Vec<SpanData>, InMemoryExporterError> {
+        let spans = self
+            .spans
             .lock()
             .map(|spans_guard| spans_guard.iter().cloned().collect())
-            .map_err(TraceError::from)
+            .map_err(InMemoryExporterError::from)?;
+        Ok(spans)
     }
 
     /// Clears the internal storage of finished spans.