Merge branch 'main' into semconv-1.30.0

.cspell.json

@@ -26,6 +26,7 @@
     // workspace dictionary.
     "words": [
         "actix",
+        "anyvalue",
         "appender",
         "appenders",
         "Bhasin",

Cargo.toml

@@ -8,6 +8,9 @@ members = [
     "stress",
 ]
 resolver = "2"
+# Avoid applying patch to force use of workspace members for this
+# not actively maintained crate
+exclude = ["opentelemetry-prometheus"]
 
 [profile.bench]
 # https://doc.rust-lang.org/cargo/reference/profiles.html#bench
@@ -50,3 +53,9 @@ tracing = { version = ">=0.1.40", default-features = false }
 tracing-core = { version = ">=0.1.33", default-features = false } 
 tracing-subscriber = { version = "0.3", default-features = false }
 url = { version = "2.5", default-features = false }
+
+# Aviod use of crates.io version of these crates through the tracing-opentelemetry dependencies
+[patch.crates-io]
+opentelemetry = { path = "opentelemetry" }
+opentelemetry_sdk = { path = "opentelemetry-sdk" }
+opentelemetry-stdout = { path = "opentelemetry-stdout" }

opentelemetry-appender-tracing/CHANGELOG.md

@@ -3,6 +3,7 @@
 ## vNext
 
 - Bump msrv to 1.75.0.
+- New experimental feature to use trace\_id & span\_id from spans created through the [tracing](https://crates.io/crates/tracing) crate (experimental_use_tracing_span_context) [#2438](https://github.com/open-telemetry/opentelemetry-rust/pull/2438)
 
 
 ## 0.27.0

opentelemetry-appender-tracing/Cargo.toml

@@ -17,6 +17,7 @@ tracing = { workspace = true, features = ["std"]}
 tracing-core = { workspace = true }
 tracing-log = { version = "0.2", optional = true }
 tracing-subscriber = { workspace = true, features = ["registry", "std"] }
+tracing-opentelemetry = { version = "0.28", optional = true }
 
 [dev-dependencies]
 log = { workspace = true }
@@ -33,6 +34,7 @@ pprof = { version = "0.14", features = ["flamegraph", "criterion"] }
 [features]
 experimental_metadata_attributes = ["dep:tracing-log"]
 spec_unstable_logs_enabled = ["opentelemetry/spec_unstable_logs_enabled"]
+experimental_use_tracing_span_context = ["tracing-opentelemetry"]
 
 
 [[bench]]

opentelemetry-appender-tracing/src/layer.rs

@@ -8,7 +8,7 @@ use tracing_core::Level;
 use tracing_core::Metadata;
 #[cfg(feature = "experimental_metadata_attributes")]
 use tracing_log::NormalizeEvent;
-use tracing_subscriber::Layer;
+use tracing_subscriber::{registry::LookupSpan, Layer};
 
 const INSTRUMENTATION_LIBRARY_NAME: &str = "opentelemetry-appender-tracing";
 
@@ -149,7 +149,7 @@ where
 
 impl<S, P, L> Layer<S> for OpenTelemetryTracingBridge<P, L>
 where
-    S: tracing::Subscriber,
+    S: tracing::Subscriber + for<'a> LookupSpan<'a>,
     P: LoggerProvider<Logger = L> + Send + Sync + 'static,
     L: Logger + Send + Sync + 'static,
 {
@@ -180,6 +180,26 @@ where
         // Visit fields.
         event.record(&mut visitor);
 
+        #[cfg(feature = "experimental_use_tracing_span_context")]
+        if let Some(span) = _ctx.event_span(event) {
+            use tracing_opentelemetry::OtelData;
+            let opt_span_id = span
+                .extensions()
+                .get::<OtelData>()
+                .and_then(|otd| otd.builder.span_id);
+
+            let opt_trace_id = span.scope().last().and_then(|root_span| {
+                root_span
+                    .extensions()
+                    .get::<OtelData>()
+                    .and_then(|otd| otd.builder.trace_id)
+            });
+
+            if let Some((trace_id, span_id)) = opt_trace_id.zip(opt_span_id) {
+                log_record.set_trace_context(trace_id, span_id, None);
+            }
+        }
+
         //emit record
         self.logger.emit(log_record);
     }
@@ -495,6 +515,67 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "experimental_use_tracing_span_context")]
+    #[test]
+    fn tracing_appender_inside_tracing_crate_context() {
+        use opentelemetry_sdk::trace::InMemorySpanExporterBuilder;
+
+        // Arrange
+        let exporter: InMemoryLogExporter = InMemoryLogExporter::default();
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+
+        // setup tracing layer to compare trace/span IDs against
+        let span_exporter = InMemorySpanExporterBuilder::new().build();
+        let tracer_provider = TracerProvider::builder()
+            .with_simple_exporter(span_exporter.clone())
+            .build();
+        let tracer = tracer_provider.tracer("test-tracer");
+
+        let level_filter = tracing_subscriber::filter::LevelFilter::INFO;
+        let log_layer =
+            layer::OpenTelemetryTracingBridge::new(&logger_provider).with_filter(level_filter);
+
+        let subscriber = tracing_subscriber::registry()
+            .with(log_layer)
+            .with(tracing_opentelemetry::layer().with_tracer(tracer));
+
+        // Avoiding global subscriber.init() as that does not play well with unit tests.
+        let _guard = tracing::subscriber::set_default(subscriber);
+
+        // Act
+        tracing::info_span!("outer-span").in_scope(|| {
+            error!("first-event");
+
+            tracing::info_span!("inner-span").in_scope(|| {
+                error!("second-event");
+            });
+        });
+
+        logger_provider.force_flush();
+
+        let logs = exporter.get_emitted_logs().expect("No emitted logs");
+        assert_eq!(logs.len(), 2);
+
+        let spans = span_exporter.get_finished_spans().unwrap();
+        assert_eq!(spans.len(), 2);
+
+        let trace_id = spans[0].span_context.trace_id();
+        assert_eq!(trace_id, spans[1].span_context.trace_id());
+        let inner_span_id = spans[0].span_context.span_id();
+        let outer_span_id = spans[1].span_context.span_id();
+        assert_eq!(outer_span_id, spans[0].parent_span_id);
+
+        let trace_ctx0 = logs[0].record.trace_context().unwrap();
+        let trace_ctx1 = logs[1].record.trace_context().unwrap();
+
+        assert_eq!(trace_ctx0.trace_id, trace_id);
+        assert_eq!(trace_ctx1.trace_id, trace_id);
+        assert_eq!(trace_ctx0.span_id, outer_span_id);
+        assert_eq!(trace_ctx1.span_id, inner_span_id);
+    }
+
     #[test]
     fn tracing_appender_standalone_with_tracing_log() {
         // Arrange

opentelemetry-otlp/src/lib.rs

@@ -7,10 +7,8 @@
 //! order to support open-source telemetry data formats (e.g. Jaeger,
 //! Prometheus, etc.) sending to multiple open-source or commercial back-ends.
 //!
-//! Currently, this crate only support sending telemetry in OTLP
-//! via grpc and http (in binary format). Supports for other format and protocol
-//! will be added in the future. The details of what's currently offering in this
-//! crate can be found in this doc.
+//! Currently, this crate supports sending telemetry in OTLP
+//! via gRPC and http (binary and json).
 //!
 //! # Quickstart
 //!
@@ -56,34 +54,36 @@
 //!
 //! ## Performance
 //!
-//! For optimal performance, a batch exporter is recommended as the simple
-//! exporter will export each span synchronously on dropping. You can enable the
-//! [`rt-tokio`], [`rt-tokio-current-thread`] or [`rt-async-std`] features and
-//! specify a runtime on the pipeline builder to have a batch exporter
-//! configured for you automatically.
+//! For optimal performance, a batch exporting processor is recommended as the simple
+//! processor will export each span synchronously on dropping, and is only good
+//! for test/debug purposes.
 //!
 //! ```toml
 //! [dependencies]
-//! opentelemetry_sdk = { version = "*", features = ["async-std"] }
 //! opentelemetry-otlp = { version = "*", features = ["grpc-tonic"] }
 //! ```
 //!
 //! ```no_run
 //! # #[cfg(all(feature = "trace", feature = "grpc-tonic"))]
 //! # {
-//! # fn main() -> Result<(), opentelemetry::trace::TraceError> {
-//! let tracer = opentelemetry_sdk::trace::TracerProvider::builder()
-//!        .with_batch_exporter(
-//!            opentelemetry_otlp::SpanExporter::builder()
-//!                .with_tonic()
-//!                .build()?,
-//!            opentelemetry_sdk::runtime::Tokio,
-//!         )
-//!        .build();
+//! use opentelemetry::global;
+//! use opentelemetry::trace::Tracer;
 //!
-//! # Ok(())
-//! # }
-//! # }
+//! 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
+//!     let _ = opentelemetry_sdk::trace::TracerProvider::builder()
+//!         .with_batch_exporter(otlp_exporter)
+//!         .build();
+//!     let tracer = global::tracer("my_tracer");
+//!     tracer.in_span("doing_work", |cx| {
+//!         // Traced app logic here...
+//!     });
+//!
+//!     Ok(())
+//!   # }
+//! }
 //! ```
 //!
 //! [`tokio`]: https://tokio.rs
@@ -92,7 +92,7 @@
 //! # Feature Flags
 //! The following feature flags can enable exporters for different telemetry signals:
 //!
-//! * `trace`: Includes the trace exporters (enabled by default).
+//! * `trace`: Includes the trace exporters.
 //! * `metrics`: Includes the metrics exporters.
 //! * `logs`: Includes the logs exporters.
 //!
@@ -101,17 +101,17 @@
 //!
 //! The following feature flags offer additional configurations on gRPC:
 //!
-//! For users uses `tonic` as grpc layer:
-//! * `grpc-tonic`: Use `tonic` as grpc layer. This is enabled by default.
+//! For users using `tonic` as grpc layer:
+//! * `grpc-tonic`: Use `tonic` as grpc layer.
 //! * `gzip-tonic`: Use gzip compression for `tonic` grpc layer.
 //! * `zstd-tonic`: Use zstd compression for `tonic` grpc layer.
 //! * `tls-roots`: Adds system trust roots to rustls-based gRPC clients using the rustls-native-certs crate
 //! * `tls-webpki-roots`: Embeds Mozilla's trust roots to rustls-based gRPC clients using the webpki-roots crate
 //!
 //! The following feature flags offer additional configurations on http:
 //!
-//! * `http-proto`: Use http as transport layer, protobuf as body format.
-//! * `reqwest-blocking-client`: Use reqwest blocking http client.
+//! * `http-proto`: Use http as transport layer, protobuf as body format. This feature is enabled by default.
+//! * `reqwest-blocking-client`: Use reqwest blocking http client. This feature is enabled by default.
 //! * `reqwest-client`: Use reqwest http client.
 //! * `reqwest-rustls`: Use reqwest with TLS with system trust roots via `rustls-native-certs` crate.
 //! * `reqwest-rustls-webpki-roots`: Use reqwest with TLS with Mozilla's trust roots via `webpki-roots` crate.
@@ -152,7 +152,7 @@
 //!         .build()?;
 //!
 //!     let tracer_provider = opentelemetry_sdk::trace::TracerProvider::builder()
-//!         .with_batch_exporter(exporter, opentelemetry_sdk::runtime::Tokio)
+//!         .with_batch_exporter(exporter)
 //!         .with_config(
 //!             trace::Config::default()
 //!                 .with_sampler(Sampler::AlwaysOn)
@@ -162,7 +162,7 @@
 //!                 .with_max_events_per_span(16)
 //!                 .with_resource(Resource::builder_empty().with_attributes([KeyValue::new("service.name", "example")]).build()),
 //!         ).build();
-//!     global::set_tracer_provider(tracer_provider);
+//!     global::set_tracer_provider(tracer_provider.clone());
 //!     let tracer = global::tracer("tracer-name");
 //!         # tracer
 //!     # };
@@ -179,7 +179,7 @@
 //!
 //!    let reader = opentelemetry_sdk::metrics::PeriodicReader::builder(exporter)
 //!        .with_interval(std::time::Duration::from_secs(3))
-//!         .with_timeout(Duration::from_secs(10))
+//!        .with_timeout(Duration::from_secs(10))
 //!        .build();
 //!
 //!    let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()

opentelemetry-prometheus/Cargo.toml

@@ -20,19 +20,19 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-once_cell = { workspace = true }
+once_cell = { version = "1.13" }
 opentelemetry = { version = "0.27", default-features = false, features = ["metrics"] }
 opentelemetry_sdk = { version = "0.27", default-features = false, features = ["metrics"] }
 prometheus = "0.13"
 protobuf = "2.14"
-tracing = {workspace = true, optional = true} # optional for opentelemetry internal logging
+tracing = {version = ">=0.1.40", default-features = false, optional = true} # optional for opentelemetry internal logging
 
 [dev-dependencies]
 opentelemetry-semantic-conventions = { version = "0.27" }
-http-body-util = { workspace = true }
-hyper = { workspace = true, features = ["full"] }
-hyper-util = { workspace = true, features = ["full"] }
-tokio = { workspace = true, features = ["full"] }
+http-body-util = { version = "0.1" }
+hyper = { version = "1.3", features = ["full"] }
+hyper-util = { version = "0.1", features = ["full"] }
+tokio = { version = "1", features = ["full"] }
 
 [features]
 default = ["internal-logs"]

opentelemetry-sdk/CHANGELOG.md

@@ -288,9 +288,12 @@ limit.
   `opentelemetry_sdk::logs::{ExportResult, LogBatch, LogExporter};`
 
 - *Breaking* `opentelemetry_sdk::LogRecord::default()` method is removed.
-  The only way to create log record outside opentelemetry_sdk crate is using 
+  The only way to create log record outside opentelemetry_sdk crate is using
   `Logger::create_log_record()` method.
 
+- Rename `opentelemetry_sdk::logs::Builder` to `opentelemetry_sdk::logs::LoggerProviderBuilder`.
+- Rename `opentelemetry_sdk::trace::Builder` to  `opentelemetry_sdk::trace::TracerProviderBuilder`.
+
 - *Breaking*: Rename namespaces for InMemoryExporters. (The module is still under "testing" feature flag)
   before:
   `opentelemetry_sdk::testing::logs::{InMemoryLogExporter, InMemoryLogExporterBuilder};`

opentelemetry-sdk/src/logs/logger_provider.rs

@@ -78,8 +78,8 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider {
 
 impl LoggerProvider {
     /// Create a new `LoggerProvider` builder.
-    pub fn builder() -> Builder {
-        Builder::default()
+    pub fn builder() -> LoggerProviderBuilder {
+        LoggerProviderBuilder::default()
     }
 
     pub(crate) fn log_processors(&self) -> &[Box<dyn LogProcessor>] {
@@ -179,12 +179,12 @@ impl Drop for LoggerProviderInner {
 
 #[derive(Debug, Default)]
 /// Builder for provider attributes.
-pub struct Builder {
+pub struct LoggerProviderBuilder {
     processors: Vec<Box<dyn LogProcessor>>,
     resource: Option<Resource>,
 }
 
-impl Builder {
+impl LoggerProviderBuilder {
     /// Adds a [SimpleLogProcessor] with the configured exporter to the pipeline.
     ///
     /// # Arguments
@@ -200,7 +200,7 @@ impl Builder {
         let mut processors = self.processors;
         processors.push(Box::new(SimpleLogProcessor::new(exporter)));
 
-        Builder { processors, ..self }
+        LoggerProviderBuilder { processors, ..self }
     }
 
     /// Adds a [BatchLogProcessor] with the configured exporter to the pipeline.
@@ -234,12 +234,12 @@ impl Builder {
         let mut processors = self.processors;
         processors.push(Box::new(processor));
 
-        Builder { processors, ..self }
+        LoggerProviderBuilder { processors, ..self }
     }
 
     /// The `Resource` to be associated with this Provider.
     pub fn with_resource(self, resource: Resource) -> Self {
-        Builder {
+        LoggerProviderBuilder {
             resource: Some(resource),
             ..self
         }

opentelemetry-sdk/src/logs/mod.rs

@@ -19,7 +19,7 @@ pub use log_processor::{
     BatchConfig, BatchConfigBuilder, BatchLogProcessor, BatchLogProcessorBuilder, LogProcessor,
     SimpleLogProcessor,
 };
-pub use logger_provider::{Builder, Logger, LoggerProvider};
+pub use logger_provider::{Logger, LoggerProvider, LoggerProviderBuilder};
 pub use record::{LogRecord, TraceContext};
 
 #[cfg(feature = "experimental_logs_batch_log_processor_with_async_runtime")]