refactor: move trace::Config methods to provider Builder

pitoniak32 · pitoniak32 · commit a53a0d5c4d80 · 2024-11-18T19:41:24.000-05:00
making this more consistent with the other signal providers #2294
diff --git a/examples/tracing-jaeger/src/main.rs b/examples/tracing-jaeger/src/main.rs
@@ -5,7 +5,7 @@ use opentelemetry::{
     KeyValue,
 };
 use opentelemetry_sdk::trace::TracerProvider;
-use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};
+use opentelemetry_sdk::{runtime, Resource};
 use opentelemetry_semantic_conventions::resource::SERVICE_NAME;
 
 use std::error::Error;
@@ -17,12 +17,10 @@ fn init_tracer_provider() -> Result<opentelemetry_sdk::trace::TracerProvider, Tr
 
     Ok(TracerProvider::builder()
         .with_batch_exporter(exporter, runtime::Tokio)
-        .with_config(
-            sdktrace::Config::default().with_resource(Resource::new(vec![KeyValue::new(
-                SERVICE_NAME,
-                "tracing-jaeger",
-            )])),
-        )
+        .with_resource(Resource::new(vec![KeyValue::new(
+            SERVICE_NAME,
+            "tracing-jaeger",
+        )]))
         .build())
 }
 
diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs
@@ -217,7 +217,6 @@ mod tests {
     use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
     use opentelemetry_sdk::logs::{LogRecord, LogResult, LoggerProvider};
     use opentelemetry_sdk::testing::logs::InMemoryLogExporter;
-    use opentelemetry_sdk::trace;
     use opentelemetry_sdk::trace::{Sampler, TracerProvider};
     use tracing::{error, warn};
     use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
@@ -402,7 +401,7 @@ mod tests {
 
         // setup tracing as well.
         let tracer_provider = TracerProvider::builder()
-            .with_config(trace::Config::default().with_sampler(Sampler::AlwaysOn))
+            .with_sampler(Sampler::AlwaysOn)
             .build();
         let tracer = tracer_provider.tracer("test-tracer");
 
@@ -579,7 +578,7 @@ mod tests {
 
         // setup tracing as well.
         let tracer_provider = TracerProvider::builder()
-            .with_config(trace::Config::default().with_sampler(Sampler::AlwaysOn))
+            .with_sampler(Sampler::AlwaysOn)
             .build();
         let tracer = tracer_provider.tracer("test-tracer");
 
diff --git a/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs b/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs
@@ -12,7 +12,7 @@ use opentelemetry_sdk::{
     logs::LoggerProvider,
     metrics::{MetricError, PeriodicReader, SdkMeterProvider},
     runtime,
-    trace::{self as sdktrace, Config, TracerProvider},
+    trace::{self as sdktrace, TracerProvider},
 };
 use opentelemetry_sdk::{
     logs::{self as sdklogs},
@@ -52,7 +52,7 @@ fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
 
     Ok(TracerProvider::builder()
         .with_batch_exporter(exporter, runtime::Tokio)
-        .with_config(Config::default().with_resource(RESOURCE.clone()))
+        .with_resource(RESOURCE.clone())
         .build())
 }
 
diff --git a/opentelemetry-otlp/examples/basic-otlp/src/main.rs b/opentelemetry-otlp/examples/basic-otlp/src/main.rs
@@ -8,7 +8,6 @@ use opentelemetry_sdk::logs::LogError;
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::metrics::MetricError;
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
-use opentelemetry_sdk::trace::Config;
 use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};
 use std::error::Error;
 use tracing::info;
@@ -28,7 +27,7 @@ fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
         .with_endpoint("http://localhost:4317")
         .build()?;
     Ok(sdktrace::TracerProvider::builder()
-        .with_config(Config::default().with_resource(RESOURCE.clone()))
+        .with_resource(RESOURCE.clone())
         .with_batch_exporter(exporter, runtime::Tokio)
         .build())
 }
diff --git a/opentelemetry-otlp/tests/integration_test/tests/traces.rs b/opentelemetry-otlp/tests/integration_test/tests/traces.rs
@@ -21,12 +21,10 @@ fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {
         .build()?;
     Ok(opentelemetry_sdk::trace::TracerProvider::builder()
         .with_batch_exporter(exporter, runtime::Tokio)
-        .with_config(
-            sdktrace::Config::default().with_resource(Resource::new(vec![KeyValue::new(
-                opentelemetry_semantic_conventions::resource::SERVICE_NAME,
-                "basic-otlp-tracing-example",
-            )])),
-        )
+        .with_resource(Resource::new(vec![KeyValue::new(
+            opentelemetry_semantic_conventions::resource::SERVICE_NAME,
+            "basic-otlp-tracing-example",
+        )]))
         .build())
 }
 
diff --git a/opentelemetry-sdk/benches/context.rs b/opentelemetry-sdk/benches/context.rs
@@ -10,7 +10,6 @@ use opentelemetry::{
 };
 use opentelemetry_sdk::{
     export::trace::{ExportResult, SpanData, SpanExporter},
-    trace,
     trace::{Sampler, TracerProvider},
 };
 #[cfg(not(target_os = "windows"))]
@@ -127,9 +126,7 @@ impl Display for Environment {
 
 fn parent_sampled_tracer(inner_sampler: Sampler) -> (TracerProvider, BoxedTracer) {
     let provider = TracerProvider::builder()
-        .with_config(
-            trace::Config::default().with_sampler(Sampler::ParentBased(Box::new(inner_sampler))),
-        )
+        .with_sampler(Sampler::ParentBased(Box::new(inner_sampler)))
         .with_simple_exporter(NoopExporter)
         .build();
     let tracer = provider.tracer(module_path!());
diff --git a/opentelemetry-sdk/benches/log.rs b/opentelemetry-sdk/benches/log.rs
@@ -25,7 +25,6 @@ use opentelemetry::trace::Tracer;
 use opentelemetry::trace::TracerProvider as _;
 use opentelemetry::{InstrumentationScope, Key};
 use opentelemetry_sdk::logs::{LogProcessor, LogRecord, LogResult, Logger, LoggerProvider};
-use opentelemetry_sdk::trace;
 use opentelemetry_sdk::trace::{Sampler, TracerProvider};
 
 #[derive(Debug)]
@@ -65,7 +64,7 @@ fn log_benchmark_group<F: Fn(&Logger)>(c: &mut Criterion, name: &str, f: F) {
 
         // setup tracing as well.
         let tracer_provider = TracerProvider::builder()
-            .with_config(trace::Config::default().with_sampler(Sampler::AlwaysOn))
+            .with_sampler(Sampler::AlwaysOn)
             .build();
         let tracer = tracer_provider.tracer("bench-tracer");
 
diff --git a/opentelemetry-sdk/benches/span_builder.rs b/opentelemetry-sdk/benches/span_builder.rs
@@ -54,7 +54,7 @@ fn span_builder_benchmark_group(c: &mut Criterion) {
 
 fn not_sampled_provider() -> (sdktrace::TracerProvider, sdktrace::Tracer) {
     let provider = sdktrace::TracerProvider::builder()
-        .with_config(sdktrace::Config::default().with_sampler(sdktrace::Sampler::AlwaysOff))
+        .with_sampler(sdktrace::Sampler::AlwaysOff)
         .with_simple_exporter(NoopExporter)
         .build();
     let tracer = provider.tracer("not-sampled");
diff --git a/opentelemetry-sdk/benches/trace.rs b/opentelemetry-sdk/benches/trace.rs
@@ -70,7 +70,7 @@ fn trace_benchmark_group<F: Fn(&sdktrace::Tracer)>(c: &mut Criterion, name: &str
 
     group.bench_function("always-sample", |b| {
         let provider = sdktrace::TracerProvider::builder()
-            .with_config(sdktrace::Config::default().with_sampler(sdktrace::Sampler::AlwaysOn))
+            .with_sampler(sdktrace::Sampler::AlwaysOn)
             .with_simple_exporter(VoidExporter)
             .build();
         let always_sample = provider.tracer("always-sample");
@@ -80,7 +80,7 @@ fn trace_benchmark_group<F: Fn(&sdktrace::Tracer)>(c: &mut Criterion, name: &str
 
     group.bench_function("never-sample", |b| {
         let provider = sdktrace::TracerProvider::builder()
-            .with_config(sdktrace::Config::default().with_sampler(sdktrace::Sampler::AlwaysOff))
+            .with_sampler(sdktrace::Sampler::AlwaysOff)
             .with_simple_exporter(VoidExporter)
             .build();
         let never_sample = provider.tracer("never-sample");
diff --git a/opentelemetry-sdk/src/resource/mod.rs b/opentelemetry-sdk/src/resource/mod.rs
@@ -95,6 +95,14 @@ impl Resource {
         }
     }
 
+    /// Create a new `Resource::default()` and merge with provided key value pairs.
+    ///
+    /// Values are de-duplicated by key, and the first key-value pair with a non-empty string value
+    /// will be retained
+    pub fn new_with_defaults<T: IntoIterator<Item = KeyValue>>(keys: T) -> Self {
+        Resource::default().merge(&mut Resource::new(keys))
+    }
+
     /// Create a new `Resource` from a key value pairs and [schema url].
     ///
     /// Values are de-duplicated by key, and the first key-value pair with a non-empty string value
diff --git a/opentelemetry-sdk/src/trace/mod.rs b/opentelemetry-sdk/src/trace/mod.rs
@@ -240,7 +240,7 @@ mod tests {
     fn trace_state_for_dropped_sampler() {
         let exporter = InMemorySpanExporterBuilder::new().build();
         let provider = TracerProvider::builder()
-            .with_config(Config::default().with_sampler(Sampler::AlwaysOff))
+            .with_sampler(Sampler::AlwaysOff)
             .with_span_processor(SimpleSpanProcessor::new(Box::new(exporter.clone())))
             .build();
 
@@ -293,7 +293,7 @@ mod tests {
     fn trace_state_for_record_only_sampler() {
         let exporter = InMemorySpanExporterBuilder::new().build();
         let provider = TracerProvider::builder()
-            .with_config(Config::default().with_sampler(TestRecordOnlySampler::default()))
+            .with_sampler(TestRecordOnlySampler::default())
             .with_span_processor(SimpleSpanProcessor::new(Box::new(exporter.clone())))
             .build();
 
diff --git a/opentelemetry-sdk/src/trace/provider.rs b/opentelemetry-sdk/src/trace/provider.rs
@@ -76,6 +76,8 @@ use std::borrow::Cow;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
+use super::IdGenerator;
+
 static PROVIDER_RESOURCE: OnceCell<Resource> = OnceCell::new();
 
 // a no nop tracer provider used as placeholder when the provider is shutdown
@@ -316,6 +318,69 @@ impl Builder {
         Builder { 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);
+        self
+    }
+
+    /// Specify the id generator to be used.
+    pub fn with_id_generator<T: IdGenerator + 'static>(mut self, id_generator: T) -> Self {
+        self.config.id_generator = Box::new(id_generator);
+        self
+    }
+
+    /// Specify the number of events to be recorded per span.
+    pub fn with_max_events_per_span(mut self, max_events: u32) -> Self {
+        self.config.span_limits.max_attributes_per_span = max_events;
+        self
+    }
+
+    /// Specify the number of attributes to be recorded per span.
+    pub fn with_max_attributes_per_span(mut self, max_attributes: u32) -> Self {
+        self.config.span_limits.max_attributes_per_span = max_attributes;
+        self
+    }
+
+    /// Specify the number of events to be recorded per span.
+    pub fn with_max_links_per_span(mut self, max_links: u32) -> Self {
+        self.config.span_limits.max_links_per_span = max_links;
+        self
+    }
+
+    /// Specify the number of attributes one event can have.
+    pub fn with_max_attributes_per_event(mut self, max_attributes: u32) -> Self {
+        self.config.span_limits.max_attributes_per_event = max_attributes;
+        self
+    }
+
+    /// Specify the number of attributes one link can have.
+    pub fn with_max_attributes_per_link(mut self, max_attributes: u32) -> Self {
+        self.config.span_limits.max_attributes_per_link = max_attributes;
+        self
+    }
+
+    /// Specify all limit via the span_limits
+    pub fn with_span_limits(mut self, span_limits: SpanLimits) -> Self {
+        self.config.span_limits = span_limits;
+        self
+    }
+
+    /// Associates a [Resource] with a [TracerProvider].
+    ///
+    /// This [Resource] represents the entity producing telemetry and is associated
+    /// with all [Tracer]s the [TracerProvider] will create.
+    ///
+    /// By default, if this option is not used, the default [Resource] will be used.
+    ///
+    /// [Tracer]: opentelemetry::trace::Tracer
+    pub fn with_resource(self, resource: Resource) -> Self {
+        Builder {
+            config: self.config.with_resource(resource),
+            ..self
+        }
+    }
+
     /// Create a new provider from this configuration.
     pub fn build(self) -> TracerProvider {
         let mut config = self.config;
@@ -367,7 +432,7 @@ mod tests {
     use crate::Resource;
     use opentelemetry::trace::{TraceError, TraceResult, Tracer, TracerProvider};
     use opentelemetry::{Context, Key, KeyValue, Value};
-    use std::borrow::Cow;
+
     use std::env;
     use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
     use std::sync::Arc;
@@ -503,13 +568,10 @@ mod tests {
 
         // If user provided config, use that.
         let custom_config_provider = super::TracerProvider::builder()
-            .with_config(Config {
-                resource: Cow::Owned(Resource::new(vec![KeyValue::new(
-                    SERVICE_NAME,
-                    "test_service",
-                )])),
-                ..Default::default()
-            })
+            .with_resource(Resource::new(vec![KeyValue::new(
+                SERVICE_NAME,
+                "test_service",
+            )]))
             .build();
         assert_resource(&custom_config_provider, SERVICE_NAME, Some("test_service"));
         assert_eq!(custom_config_provider.config().resource.len(), 1);
@@ -538,13 +600,10 @@ mod tests {
             Some("my-custom-key=env-val,k2=value2"),
             || {
                 let user_provided_resource_config_provider = super::TracerProvider::builder()
-                    .with_config(Config {
-                        resource: Cow::Owned(Resource::default().merge(&mut Resource::new(vec![
-                            KeyValue::new("my-custom-key", "my-custom-value"),
-                            KeyValue::new("my-custom-key2", "my-custom-value2"),
-                        ]))),
-                        ..Default::default()
-                    })
+                    .with_resource(Resource::new_with_defaults(vec![
+                        KeyValue::new("my-custom-key", "my-custom-value"),
+                        KeyValue::new("my-custom-key2", "my-custom-value2"),
+                    ]))
                     .build();
                 assert_resource(
                     &user_provided_resource_config_provider,
@@ -579,10 +638,7 @@ mod tests {
 
         // If user provided a resource, it takes priority during collision.
         let no_service_name = super::TracerProvider::builder()
-            .with_config(Config {
-                resource: Cow::Owned(Resource::empty()),
-                ..Default::default()
-            })
+            .with_resource(Resource::empty())
             .build();
 
         assert_eq!(no_service_name.config().resource.len(), 0)
diff --git a/opentelemetry-sdk/src/trace/tracer.rs b/opentelemetry-sdk/src/trace/tracer.rs
@@ -285,7 +285,7 @@ impl opentelemetry::trace::Tracer for Tracer {
 mod tests {
     use crate::{
         testing::trace::TestSpan,
-        trace::{Config, Sampler, ShouldSample},
+        trace::{Sampler, ShouldSample},
     };
     use opentelemetry::{
         trace::{
@@ -326,9 +326,8 @@ mod tests {
     fn allow_sampler_to_change_trace_state() {
         // Setup
         let sampler = TestSampler {};
-        let config = Config::default().with_sampler(sampler);
         let tracer_provider = crate::trace::TracerProvider::builder()
-            .with_config(config)
+            .with_sampler(sampler)
             .build();
         let tracer = tracer_provider.tracer("test");
         let trace_state = TraceState::from_key_value(vec![("foo", "bar")]).unwrap();
@@ -351,9 +350,8 @@ mod tests {
     #[test]
     fn drop_parent_based_children() {
         let sampler = Sampler::ParentBased(Box::new(Sampler::AlwaysOn));
-        let config = Config::default().with_sampler(sampler);
         let tracer_provider = crate::trace::TracerProvider::builder()
-            .with_config(config)
+            .with_sampler(sampler)
             .build();
 
         let context = Context::current_with_span(TestSpan(SpanContext::empty_context()));
@@ -366,9 +364,8 @@ mod tests {
     #[test]
     fn uses_current_context_for_builders_if_unset() {
         let sampler = Sampler::ParentBased(Box::new(Sampler::AlwaysOn));
-        let config = Config::default().with_sampler(sampler);
         let tracer_provider = crate::trace::TracerProvider::builder()
-            .with_config(config)
+            .with_sampler(sampler)
             .build();
         let tracer = tracer_provider.tracer("test");
 
diff --git a/opentelemetry-stdout/examples/basic.rs b/opentelemetry-stdout/examples/basic.rs
@@ -12,7 +12,6 @@ use opentelemetry_sdk::runtime;
 #[cfg(feature = "metrics")]
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 
-use opentelemetry_sdk::trace::Config;
 #[cfg(feature = "trace")]
 use opentelemetry_sdk::trace::TracerProvider;
 use opentelemetry_sdk::Resource;
@@ -29,7 +28,7 @@ fn init_trace() {
     let exporter = opentelemetry_stdout::SpanExporter::default();
     let provider = TracerProvider::builder()
         .with_simple_exporter(exporter)
-        .with_config(Config::default().with_resource(RESOURCE.clone()))
+        .with_resource(RESOURCE.clone())
         .build();
     global::set_tracer_provider(provider);
 }
diff --git a/opentelemetry-zipkin/src/exporter/mod.rs b/opentelemetry-zipkin/src/exporter/mod.rs
diff --git a/stress/src/traces.rs b/stress/src/traces.rs

Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,14 @@ impl Resource {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
	`98`	+ /// Create a new `Resource::default()` and merge with provided key value pairs.
	`99`	`+ ///`
	`100`	`+ /// Values are de-duplicated by key, and the first key-value pair with a non-empty string value`
	`101`	`+ /// will be retained`
	`102`	`+ pub fn new_with_defaults<T: IntoIterator<Item = KeyValue>>(keys: T) -> Self {`
	`103`	`+ Resource::default().merge(&mut Resource::new(keys))`
	`104`	`+ }`
	`105`	`+`
`98`	`106`	/// Create a new `Resource` from a key value pairs and [schema url].
`99`	`107`	`///`
`100`	`108`	`/// Values are de-duplicated by key, and the first key-value pair with a non-empty string value`