Merge branch 'main' into cijothomas/addscott-approver

Author: cijothomas

examples/tracing-jaeger/src/main.rs

@@ -1,9 +1,9 @@
 use opentelemetry::{
     global,
-    trace::{TraceContextExt, TraceError, Tracer},
+    trace::{TraceContextExt, Tracer},
     KeyValue,
 };
-use opentelemetry_sdk::trace::SdkTracerProvider;
+use opentelemetry_sdk::trace::{SdkTracerProvider, TraceError};
 use opentelemetry_sdk::Resource;
 
 use std::error::Error;

opentelemetry-appender-tracing/CHANGELOG.md

@@ -5,6 +5,32 @@
 Fixes [1682](https://github.com/open-telemetry/opentelemetry-rust/issues/1682).
 "spec_unstable_logs_enabled" feature now do not suppress logs for other layers.
 
+The special treatment of the "message" field has been extended when recording
+string values. With this change, when a log is emitted with a field named
+"message" (and string value), its value is directly assigned to the LogRecord’s
+body rather than being stored as an attribute named "message". This offers a
+slight performance improvement over previous.
+
+For example, the below will now produce LogRecord with the message value
+populated as LogRecord's body:
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]", message = "This is an example message");
+```
+
+Previously, Body was only populated when the below style was used.
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]", "This is an example message");
+```
+
+This style, while slightly slower, should still be used when the value is not a
+simple string, but require format arguments as in the below example.
+
+```rust
+error!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]", "This is an example message with format arguments {} and {}", "foo", "bar");
+```
+
 ## 0.28.1
 
 Released 2025-Feb-12

opentelemetry-appender-tracing/src/layer.rs

@@ -88,15 +88,14 @@ impl<LR: LogRecord> tracing::field::Visit for EventVisitor<'_, LR> {
         if is_duplicated_metadata(field.name()) {
             return;
         }
-        //TODO: Consider special casing "message" to populate body and document
-        // to users to use message field for log message, to avoid going to the
-        // record_debug, which has dyn dispatch, string allocation and
-        // formatting cost.
-
         //TODO: Fix heap allocation. Check if lifetime of &str can be used
         // to optimize sync exporter scenario.
-        self.log_record
-            .add_attribute(Key::new(field.name()), AnyValue::from(value.to_owned()));
+        if field.name() == "message" {
+            self.log_record.set_body(AnyValue::from(value.to_owned()));
+        } else {
+            self.log_record
+                .add_attribute(Key::new(field.name()), AnyValue::from(value.to_owned()));
+        }
     }
 
     fn record_bool(&mut self, field: &tracing_core::Field, value: bool) {

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

@@ -120,7 +120,7 @@ impl HttpExporterBuilder {
             .or(env::var(OTEL_EXPORTER_OTLP_TIMEOUT).ok())
         {
             Some(val) => match val.parse() {
-                Ok(seconds) => Duration::from_millis(seconds),
+                Ok(milli_seconds) => Duration::from_millis(milli_seconds),
                 Err(_) => self.exporter_config.timeout,
             },
             None => self.exporter_config.timeout,
@@ -210,7 +210,7 @@ impl HttpExporterBuilder {
     #[cfg(feature = "trace")]
     pub fn build_span_exporter(
         mut self,
-    ) -> Result<crate::SpanExporter, opentelemetry::trace::TraceError> {
+    ) -> Result<crate::SpanExporter, opentelemetry_sdk::trace::TraceError> {
         use crate::{
             OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_HEADERS,
             OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
@@ -301,7 +301,7 @@ impl OtlpHttpClient {
     fn build_trace_export_body(
         &self,
         spans: Vec<SpanData>,
-    ) -> opentelemetry::trace::TraceResult<(Vec<u8>, &'static str)> {
+    ) -> opentelemetry_sdk::trace::TraceResult<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::trace::v1::ExportTraceServiceRequest;
         let resource_spans = group_spans_by_resource_and_scope(spans, &self.resource);
 
@@ -310,7 +310,7 @@ impl OtlpHttpClient {
             #[cfg(feature = "http-json")]
             Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
                 Ok(json) => Ok((json.into(), "application/json")),
-                Err(e) => Err(opentelemetry::trace::TraceError::from(e.to_string())),
+                Err(e) => Err(opentelemetry_sdk::trace::TraceError::from(e.to_string())),
             },
             _ => Ok((req.encode_to_vec(), "application/x-protobuf")),
         }

opentelemetry-otlp/src/exporter/mod.rs

@@ -52,7 +52,7 @@ const OTEL_EXPORTER_OTLP_PROTOCOL_HTTP_JSON: &str = "http/json";
 /// Max waiting time for the backend to process each signal batch, defaults to 10 seconds.
 pub const OTEL_EXPORTER_OTLP_TIMEOUT: &str = "OTEL_EXPORTER_OTLP_TIMEOUT";
 /// Default max waiting time for the backend to process each signal batch.
-pub const OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT: u64 = 10000;
+pub const OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT: Duration = Duration::from_millis(10000);
 
 // Endpoints per protocol https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md
 #[cfg(feature = "grpc-tonic")]
@@ -87,7 +87,7 @@ impl Default for ExportConfig {
             // don't use default_endpoint(protocol) here otherwise we
             // won't know if user provided a value
             protocol,
-            timeout: Duration::from_millis(OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT),
+            timeout: OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT,
         }
     }
 }

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

@@ -200,7 +200,7 @@ impl TonicExporterBuilder {
             .or(env::var(OTEL_EXPORTER_OTLP_TIMEOUT).ok())
         {
             Some(val) => match val.parse() {
-                Ok(seconds) => Duration::from_millis(seconds),
+                Ok(milli_seconds) => Duration::from_millis(milli_seconds),
                 Err(_) => config.timeout,
             },
             None => config.timeout,
@@ -303,7 +303,7 @@ impl TonicExporterBuilder {
     #[cfg(feature = "trace")]
     pub(crate) fn build_span_exporter(
         self,
-    ) -> Result<crate::SpanExporter, opentelemetry::trace::TraceError> {
+    ) -> Result<crate::SpanExporter, opentelemetry_sdk::trace::TraceError> {
         use crate::exporter::tonic::trace::TonicTracesClient;
 
         otel_debug!(name: "TracesTonicChannelBuilding");

opentelemetry-otlp/src/lib.rs

@@ -384,12 +384,6 @@ impl ExportError for Error {
     }
 }
 
-impl opentelemetry::trace::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-otlp/src/span.rs

@@ -5,7 +5,7 @@
 use std::fmt::Debug;
 
 use opentelemetry_sdk::error::OTelSdkResult;
-use opentelemetry_sdk::trace::SpanData;
+use opentelemetry_sdk::trace::{SpanData, TraceError};
 
 #[cfg(feature = "grpc-tonic")]
 use crate::{
@@ -62,7 +62,7 @@ impl SpanExporterBuilder<NoExporterBuilderSet> {
 
 #[cfg(feature = "grpc-tonic")]
 impl SpanExporterBuilder<TonicExporterBuilderSet> {
-    pub fn build(self) -> Result<SpanExporter, opentelemetry::trace::TraceError> {
+    pub fn build(self) -> Result<SpanExporter, TraceError> {
         let span_exporter = self.client.0.build_span_exporter()?;
         opentelemetry::otel_debug!(name: "SpanExporterBuilt");
         Ok(span_exporter)
@@ -71,7 +71,7 @@ impl SpanExporterBuilder<TonicExporterBuilderSet> {
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
 impl SpanExporterBuilder<HttpExporterBuilderSet> {
-    pub fn build(self) -> Result<SpanExporter, opentelemetry::trace::TraceError> {
+    pub fn build(self) -> Result<SpanExporter, TraceError> {
         let span_exporter = self.client.0.build_span_exporter()?;
         Ok(span_exporter)
     }

opentelemetry-otlp/tests/integration_test/tests/traces.rs

@@ -3,15 +3,14 @@
 use std::{fs::File, os::unix::fs::MetadataExt};
 
 use integration_test_runner::trace_asserter::{read_spans_from_json, TraceAsserter};
-use opentelemetry::trace::TraceError;
 use opentelemetry_otlp::SpanExporter;
 
 use anyhow::Result;
 use ctor::dtor;
 use integration_test_runner::test_utils;
 use opentelemetry_sdk::{trace as sdktrace, Resource};
 
-fn init_tracer_provider() -> Result<sdktrace::SdkTracerProvider, TraceError> {
+fn init_tracer_provider() -> Result<sdktrace::SdkTracerProvider, sdktrace::TraceError> {
     let exporter_builder = SpanExporter::builder();
     #[cfg(feature = "tonic-client")]
     let exporter_builder = exporter_builder.with_tonic();

opentelemetry-sdk/CHANGELOG.md

@@ -2,7 +2,37 @@
 
 ## vNext
 
-- *Breaking* Make `force_flush()` in `PushMetricExporter` synchronous
+- Calls to `MeterProviderBuilder::with_resource`, `TracerProviderBuilder::with_resource`,
+  `LoggerProviderBuilder::with_resource` are now additive ([#2677](https://github.com/open-telemetry/opentelemetry-rust/pull/2677)).
+- Moved `ExportError` trait from `opentelemetry::trace::ExportError` to `opentelemetry_sdk::export::ExportError`
+- Moved `TraceError` enum from `opentelemetry::trace::TraceError` to `opentelemetry_sdk::trace::TraceError`
+- Moved `TraceResult` type alias from `opentelemetry::trace::TraceResult` to `opentelemetry_sdk::trace::TraceResult`
+- *Breaking*: Make `force_flush()` in `PushMetricExporter` synchronous
+- **Breaking Change:** Updated the `SpanExporter` trait method signature:
+
+```rust
+  fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult>;
+```
+
+  to
+
+```rust
+  fn export(
+    &mut self,
+    batch: Vec<SpanData>,
+) -> impl std::future::Future<Output = OTelSdkResult> + Send;
+```
+
+  This affects anyone who writes custom exporters, as custom implementations of SpanExporter
+  should now define export as an `async fn`:
+
+```rust
+  impl trace::SpanExporter for CustomExporter {
+    async fn export(&mut self, batch: Vec<trace::SpanData>) -> OTelSdkResult {
+        // Implementation here
+    }
+}
+```
 
 ## 0.28.0