Merge branch 'main' into cijothomas/jaeger

Author: cijothomas

opentelemetry-otlp/src/lib.rs

@@ -207,15 +207,12 @@
 //!
 //!     let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
 //!         .with_batch_exporter(exporter)
-//!         .with_config(
-//!             trace::Config::default()
-//!                 .with_sampler(Sampler::AlwaysOn)
-//!                 .with_id_generator(RandomIdGenerator::default())
-//!                 .with_max_events_per_span(64)
-//!                 .with_max_attributes_per_span(16)
-//!                 .with_max_events_per_span(16)
-//!                 .with_resource(Resource::builder_empty().with_attributes([KeyValue::new("service.name", "example")]).build()),
-//!         ).build();
+//!         .with_sampler(Sampler::AlwaysOn)
+//!         .with_id_generator(RandomIdGenerator::default())
+//!         .with_max_events_per_span(64)
+//!         .with_max_attributes_per_span(16)
+//!         .with_resource(Resource::builder_empty().with_attributes([KeyValue::new("service.name", "example")]).build())
+//!         .build();
 //!     global::set_tracer_provider(tracer_provider.clone());
 //!     let tracer = global::tracer("tracer-name");
 //!         # tracer

opentelemetry-sdk/CHANGELOG.md

@@ -74,6 +74,7 @@
 - **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` 
 
 ## 0.28.0
 

opentelemetry-sdk/src/lib.rs

@@ -136,7 +136,6 @@ pub mod runtime;
 #[cfg_attr(docsrs, doc(cfg(any(feature = "testing", test))))]
 pub mod testing;
 
-#[allow(deprecated)]
 #[cfg(feature = "trace")]
 #[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
 pub mod trace;

opentelemetry-sdk/src/trace/config.rs

@@ -9,12 +9,6 @@ use std::borrow::Cow;
 use std::env;
 use std::str::FromStr;
 
-/// Default trace configuration
-#[deprecated(since = "0.23.0", note = "Use Config::default() instead")]
-pub fn config() -> Config {
-    Config::default()
-}
-
 /// Tracer configuration
 #[derive(Debug)]
 #[non_exhaustive]
@@ -32,98 +26,6 @@ pub struct Config {
     pub resource: Cow<'static, Resource>,
 }
 
-impl Config {
-    /// Specify the sampler to be used.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_sampler(...) instead."
-    )]
-    pub fn with_sampler<T: crate::trace::ShouldSample + 'static>(mut self, sampler: T) -> Self {
-        self.sampler = Box::new(sampler);
-        self
-    }
-
-    /// Specify the id generator to be used.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_id_generator(...) instead."
-    )]
-    pub fn with_id_generator<T: IdGenerator + 'static>(mut self, id_generator: T) -> Self {
-        self.id_generator = Box::new(id_generator);
-        self
-    }
-
-    /// Specify the maximum number of events that can be recorded per span.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_max_events_per_span(...) instead."
-    )]
-    pub fn with_max_events_per_span(mut self, max_events: u32) -> Self {
-        self.span_limits.max_events_per_span = max_events;
-        self
-    }
-
-    /// Specify the maximum number of attributes that can be recorded per span.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_max_attributes_per_span(...) instead."
-    )]
-    pub fn with_max_attributes_per_span(mut self, max_attributes: u32) -> Self {
-        self.span_limits.max_attributes_per_span = max_attributes;
-        self
-    }
-
-    /// Specify the maximum number of links that can be recorded per span.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_max_links_per_span(...) instead."
-    )]
-    pub fn with_max_links_per_span(mut self, max_links: u32) -> Self {
-        self.span_limits.max_links_per_span = max_links;
-        self
-    }
-
-    /// Specify the maximum number of attributes one event can have.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_max_attributes_per_event(...) instead."
-    )]
-    pub fn with_max_attributes_per_event(mut self, max_attributes: u32) -> Self {
-        self.span_limits.max_attributes_per_event = max_attributes;
-        self
-    }
-
-    /// Specify the maximum number of attributes one link can have.
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_max_attributes_per_link(...) instead."
-    )]
-    pub fn with_max_attributes_per_link(mut self, max_attributes: u32) -> Self {
-        self.span_limits.max_attributes_per_link = max_attributes;
-        self
-    }
-
-    /// Specify all limit via the span_limits
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_span_limits(...) instead."
-    )]
-    pub fn with_span_limits(mut self, span_limits: SpanLimits) -> Self {
-        self.span_limits = span_limits;
-        self
-    }
-
-    /// Specify the attributes representing the entity that produces telemetry
-    #[deprecated(
-        since = "0.27.1",
-        note = "Config is becoming private. Please use Builder::with_resource(...) instead."
-    )]
-    pub fn with_resource(mut self, resource: Resource) -> Self {
-        self.resource = Cow::Owned(resource);
-        self
-    }
-}
-
 impl Default for Config {
     /// Create default global sdk configuration.
     fn default() -> Self {

opentelemetry-sdk/src/trace/mod.rs

@@ -22,7 +22,7 @@ mod span_processor;
 pub mod span_processor_with_async_runtime;
 mod tracer;
 
-pub use config::{config, Config};
+pub use config::Config;
 pub use error::{TraceError, TraceResult};
 pub use events::SpanEvents;
 pub use export::{SpanData, SpanExporter};

opentelemetry-sdk/src/trace/provider.rs

@@ -345,15 +345,6 @@ impl TracerProviderBuilder {
         TracerProviderBuilder { processors, ..self }
     }
 
-    /// The sdk [`crate::trace::Config`] that this provider will use.
-    #[deprecated(
-        since = "0.27.1",
-        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 {
-        TracerProviderBuilder { config, ..self }
-    }
-
     /// Specify the sampler to be used.
     pub fn with_sampler<T: crate::trace::ShouldSample + 'static>(mut self, sampler: T) -> Self {
         self.config.sampler = Box::new(sampler);
@@ -428,7 +419,7 @@ impl TracerProviderBuilder {
 
         // Now, we can update the config with the resource.
         if let Some(resource) = self.resource {
-            config = config.with_resource(resource);
+            config.resource = Cow::Owned(resource);
         };
 
         // Standard config will contain an owned [`Resource`] (either sdk default or use supplied)

opentelemetry-sdk/src/trace/sampler/jaeger_remote/sampler.rs

@@ -234,7 +234,7 @@ impl JaegerRemoteSampler {
             .unwrap();
 
         let resp = client
-            .send(request)
+            .send_bytes(request)
             .await
             .map_err(|err| format!("the request is failed to send {}", err))?;
 

opentelemetry-sdk/src/trace/span_processor.rs

@@ -704,6 +704,8 @@ impl Default for BatchConfigBuilder {
     /// * `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
     /// * `OTEL_BSP_EXPORT_TIMEOUT`
     /// * `OTEL_BSP_MAX_CONCURRENT_EXPORTS`
+    ///
+    /// Note: Programmatic configuration overrides any value set via the environment variable.
     fn default() -> Self {
         BatchConfigBuilder {
             max_queue_size: OTEL_BSP_MAX_QUEUE_SIZE_DEFAULT,
@@ -720,7 +722,11 @@ impl BatchConfigBuilder {
     /// Set max_queue_size for [`BatchConfigBuilder`].
     /// It's the maximum queue size to buffer spans for delayed processing.
     /// If the queue gets full it will drops the spans.
-    /// The default value of is 2048.
+    /// The default value is 2048.
+    ///
+    /// Corresponding environment variable: `OTEL_BSP_MAX_QUEUE_SIZE`.
+    ///
+    /// Note: Programmatically setting this will override any value set via the environment variable.
     pub fn with_max_queue_size(mut self, max_queue_size: usize) -> Self {
         self.max_queue_size = max_queue_size;
         self
@@ -731,6 +737,10 @@ impl BatchConfigBuilder {
     /// more than one batch worth of spans then it processes multiple batches
     /// of spans one batch after the other without any delay. The default value
     /// is 512.
+    ///
+    /// Corresponding environment variable: `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`.
+    ///
+    /// Note: Programmatically setting this will override any value set via the environment variable.
     pub fn with_max_export_batch_size(mut self, max_export_batch_size: usize) -> Self {
         self.max_export_batch_size = max_export_batch_size;
         self
@@ -743,6 +753,11 @@ impl BatchConfigBuilder {
     /// The default value is 1.
     /// If the max_concurrent_exports value is default value, it will cause exports to be performed
     /// synchronously on the BatchSpanProcessor task.
+    /// The default value is 1.
+    ///
+    /// Corresponding environment variable: `OTEL_BSP_MAX_CONCURRENT_EXPORTS`.
+    ///
+    /// Note: Programmatically setting this will override any value set via the environment variable.
     pub fn with_max_concurrent_exports(mut self, max_concurrent_exports: usize) -> Self {
         self.max_concurrent_exports = max_concurrent_exports;
         self
@@ -751,6 +766,10 @@ impl BatchConfigBuilder {
     /// Set scheduled_delay_duration for [`BatchConfigBuilder`].
     /// It's the delay interval in milliseconds between two consecutive processing of batches.
     /// The default value is 5000 milliseconds.
+    ///
+    /// Corresponding environment variable: `OTEL_BSP_SCHEDULE_DELAY`.
+    ///
+    /// Note: Programmatically setting this will override any value set via the environment variable.
     pub fn with_scheduled_delay(mut self, scheduled_delay: Duration) -> Self {
         self.scheduled_delay = scheduled_delay;
         self
@@ -759,6 +778,10 @@ impl BatchConfigBuilder {
     /// Set max_export_timeout for [`BatchConfigBuilder`].
     /// It's the maximum duration to export a batch of data.
     /// The The default value is 30000 milliseconds.
+    ///
+    /// Corresponding environment variable: `OTEL_BSP_EXPORT_TIMEOUT`.
+    ///
+    /// Note: Programmatically setting this will override any value set via the environment variable.
     #[cfg(feature = "experimental_trace_batch_span_processor_with_async_runtime")]
     pub fn with_max_export_timeout(mut self, max_export_timeout: Duration) -> Self {
         self.max_export_timeout = max_export_timeout;
@@ -932,6 +955,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_code_based_config_overrides_env_vars() {
+        let env_vars = vec![
+            (OTEL_BSP_EXPORT_TIMEOUT, Some("60000")),
+            (OTEL_BSP_MAX_CONCURRENT_EXPORTS, Some("5")),
+            (OTEL_BSP_MAX_EXPORT_BATCH_SIZE, Some("1024")),
+            (OTEL_BSP_MAX_QUEUE_SIZE, Some("4096")),
+            (OTEL_BSP_SCHEDULE_DELAY, Some("2000")),
+        ];
+
+        temp_env::with_vars(env_vars, || {
+            let config = BatchConfigBuilder::default()
+                .with_max_export_batch_size(512)
+                .with_max_queue_size(2048)
+                .with_scheduled_delay(Duration::from_millis(1000));
+            #[cfg(feature = "experimental_trace_batch_span_processor_with_async_runtime")]
+            let config = {
+                config
+                    .with_max_concurrent_exports(10)
+                    .with_max_export_timeout(Duration::from_millis(2000))
+            };
+            let config = config.build();
+
+            assert_eq!(config.max_export_batch_size, 512);
+            assert_eq!(config.max_queue_size, 2048);
+            assert_eq!(config.scheduled_delay, Duration::from_millis(1000));
+            #[cfg(feature = "experimental_trace_batch_span_processor_with_async_runtime")]
+            {
+                assert_eq!(config.max_concurrent_exports, 10);
+                assert_eq!(config.max_export_timeout, Duration::from_millis(2000));
+            }
+        });
+    }
+
     #[test]
     fn test_batch_config_configurable_by_env_vars() {
         let env_vars = vec![

opentelemetry-semantic-conventions/src/resource.rs

@@ -15,7 +15,7 @@
 //!
 //! ```rust
 //! use opentelemetry::KeyValue;
-//! use opentelemetry_sdk::{trace::{config, SdkTracerProvider}, Resource};
+//! use opentelemetry_sdk::{trace::SdkTracerProvider, Resource};
 //! use opentelemetry_semantic_conventions as semconv;
 //!
 //! let _tracer = SdkTracerProvider::builder()

opentelemetry/src/context.rs

@@ -1,3 +1,14 @@
+//! Execution-scoped context propagation.
+//!
+//! The `context` module provides mechanisms for propagating values across API boundaries and between
+//! logically associated execution units. It enables cross-cutting concerns to access their data in-process
+//! using a shared context object.
+//!
+//! # Main Types
+//!
+//! - [`Context`]: An immutable, execution-scoped collection of values.
+//!
+
 use crate::otel_warn;
 #[cfg(feature = "trace")]
 use crate::trace::context::SynchronizedSpan;
@@ -9,6 +20,10 @@ use std::hash::{BuildHasherDefault, Hasher};
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+mod future_ext;
+
+pub use future_ext::FutureExt;
+
 thread_local! {
     static CURRENT_CONTEXT: RefCell<ContextStack> = RefCell::new(ContextStack::default());
 }
@@ -78,7 +93,7 @@ thread_local! {
 #[derive(Clone, Default)]
 pub struct Context {
     #[cfg(feature = "trace")]
-    pub(super) span: Option<Arc<SynchronizedSpan>>,
+    pub(crate) span: Option<Arc<SynchronizedSpan>>,
     entries: Option<Arc<EntryMap>>,
 }
 
@@ -314,15 +329,15 @@ impl Context {
     }
 
     #[cfg(feature = "trace")]
-    pub(super) fn current_with_synchronized_span(value: SynchronizedSpan) -> Self {
+    pub(crate) fn current_with_synchronized_span(value: SynchronizedSpan) -> Self {
         Context {
             span: Some(Arc::new(value)),
             entries: Context::map_current(|cx| cx.entries.clone()),
         }
     }
 
     #[cfg(feature = "trace")]
-    pub(super) fn with_synchronized_span(&self, value: SynchronizedSpan) -> Self {
+    pub(crate) fn with_synchronized_span(&self, value: SynchronizedSpan) -> Self {
         Context {
             span: Some(Arc::new(value)),
             entries: self.entries.clone(),