Merge branch 'main' into anujnegi/disable-name-check

Author: anujnegi270

.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-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/log_emitter.rs 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

@@ -1,8 +1,8 @@
 //! # OpenTelemetry Log SDK
 mod error;
 mod export;
-mod log_emitter;
 mod log_processor;
+mod logger_provider;
 pub(crate) mod record;
 
 /// In-Memory log exporter for testing purpose.
@@ -15,11 +15,11 @@ pub use in_memory_exporter::{InMemoryLogExporter, InMemoryLogExporterBuilder};
 
 pub use error::{LogError, LogResult};
 pub use export::{ExportResult, LogBatch, LogExporter};
-pub use log_emitter::{Builder, Logger, LoggerProvider};
 pub use log_processor::{
     BatchConfig, BatchConfigBuilder, BatchLogProcessor, BatchLogProcessorBuilder, LogProcessor,
     SimpleLogProcessor,
 };
+pub use logger_provider::{Logger, LoggerProvider, LoggerProviderBuilder};
 pub use record::{LogRecord, TraceContext};
 
 #[cfg(feature = "experimental_logs_batch_log_processor_with_async_runtime")]

opentelemetry-sdk/src/trace/mod.rs

@@ -35,7 +35,7 @@ pub use in_memory_exporter::{InMemorySpanExporter, InMemorySpanExporterBuilder};
 
 pub use id_generator::{IdGenerator, RandomIdGenerator};
 pub use links::SpanLinks;
-pub use provider::{Builder, TracerProvider};
+pub use provider::{TracerProvider, TracerProviderBuilder};
 pub use sampler::{Sampler, ShouldSample};
 pub use span::Span;
 pub use span_limit::SpanLimits;

opentelemetry-sdk/src/trace/provider.rs

@@ -167,8 +167,8 @@ impl TracerProvider {
     }
 
     /// Create a new [`TracerProvider`] builder.
-    pub fn builder() -> Builder {
-        Builder::default()
+    pub fn builder() -> TracerProviderBuilder {
+        TracerProviderBuilder::default()
     }
 
     /// Span processors associated with this provider
@@ -274,12 +274,12 @@ impl opentelemetry::trace::TracerProvider for TracerProvider {
 
 /// Builder for provider attributes.
 #[derive(Debug, Default)]
-pub struct Builder {
+pub struct TracerProviderBuilder {
     processors: Vec<Box<dyn SpanProcessor>>,
     config: crate::trace::Config,
 }
 
-impl Builder {
+impl TracerProviderBuilder {
     /// Adds a [SimpleSpanProcessor] with the configured exporter to the pipeline.
     ///
     /// # Arguments
@@ -295,7 +295,7 @@ impl Builder {
         let mut processors = self.processors;
         processors.push(Box::new(SimpleSpanProcessor::new(Box::new(exporter))));
 
-        Builder { processors, ..self }
+        TracerProviderBuilder { processors, ..self }
     }
 
     /// Adds a [BatchSpanProcessor] with the configured exporter to the pipeline.
@@ -329,7 +329,7 @@ impl Builder {
         let mut processors = self.processors;
         processors.push(Box::new(processor));
 
-        Builder { processors, ..self }
+        TracerProviderBuilder { processors, ..self }
     }
 
     /// The sdk [`crate::trace::Config`] that this provider will use.
@@ -338,7 +338,7 @@ impl Builder {
         note = "Config is becoming a private type. Use Builder::with_{config_name}(resource) instead. ex: Builder::with_resource(resource)"
     )]
     pub fn with_config(self, config: crate::trace::Config) -> Self {
-        Builder { config, ..self }
+        TracerProviderBuilder { config, ..self }
     }
 
     /// Specify the sampler to be used.
@@ -398,7 +398,7 @@ impl Builder {
     ///
     /// [Tracer]: opentelemetry::trace::Tracer
     pub fn with_resource(self, resource: Resource) -> Self {
-        Builder {
+        TracerProviderBuilder {
             config: self.config.with_resource(resource),
             ..self
         }

opentelemetry-stdout/src/logs/exporter.rs

@@ -75,7 +75,10 @@ impl opentelemetry_sdk::logs::LogExporter for LogExporter {
 fn print_logs(batch: LogBatch<'_>) {
     for (i, log) in batch.iter().enumerate() {
         println!("Log #{}", i);
-        let (record, _library) = log;
+        let (record, library) = log;
+
+        println!("\t Instrumentation Scope: {:?}", library);
+
         if let Some(event_name) = record.event_name() {
             println!("\t EventName: {:?}", event_name);
         }

opentelemetry/Cargo.toml

@@ -34,10 +34,9 @@ js-sys = "0.3.63"
 default = ["trace", "metrics", "logs", "internal-logs"]
 trace = ["pin-project-lite", "futures-sink", "futures-core", "thiserror"]
 metrics = []
-testing = ["trace", "metrics"]
+testing = ["trace"]
 logs = []
 spec_unstable_logs_enabled = ["logs"]
-otel_unstable = []
 internal-logs = ["tracing"]
 
 [dev-dependencies]

opentelemetry/src/global/internal_logging.rs

@@ -1,7 +1,7 @@
 #![allow(unused_macros)]
 ///
 /// **Note**: These macros (`otel_info!`, `otel_warn!`, `otel_debug!`, and `otel_error!`) are intended to be used
-/// **internally within OpenTelemetry code** or for **custom exporters and processors**. They are not designed
+/// **internally within OpenTelemetry code** or for **custom exporters, processors and other plugins**. They are not designed
 /// for general application logging and should not be used for that purpose.
 ///
 /// Macro for logging informational messages in OpenTelemetry.

opentelemetry/src/global/metrics.rs

@@ -15,6 +15,7 @@ fn global_meter_provider() -> &'static RwLock<GlobalMeterProvider> {
 
 /// Sets the given [`MeterProvider`] instance as the current global meter
 /// provider.
+/// Libraries should NOT call this function. It is intended for applications/executables.
 ///
 /// **NOTE:** This function should be called before getting [`Meter`] instances via [`meter()`] or [`meter_with_scope()`]. Otherwise, you could get no-op [`Meter`] instances.
 pub fn set_meter_provider<P>(new_provider: P)

opentelemetry/src/global/trace.rs

@@ -422,6 +422,7 @@ pub fn tracer_with_scope(scope: InstrumentationScope) -> BoxedTracer {
 /// It returns the [`TracerProvider`] instance that was previously mounted as global provider
 /// (e.g. [`NoopTracerProvider`] if a provider had not been set before).
 ///
+/// Libraries should NOT call this function. It is intended for applications/executables.
 /// [`TracerProvider`]: crate::trace::TracerProvider
 pub fn set_tracer_provider<P, T, S>(new_provider: P) -> GlobalTracerProvider
 where