Implement additive with_resource for all signals

Author: martintmk

opentelemetry-sdk/src/logs/logger_provider.rs

@@ -235,11 +235,16 @@ impl LoggerProviderBuilder {
     }
 
     /// The `Resource` to be associated with this Provider.
+    ///
+    /// *Note*: Calls to this method are additive, each call merges the provided
+    /// resource with the previous one.
     pub fn with_resource(self, resource: Resource) -> Self {
-        LoggerProviderBuilder {
-            resource: Some(resource),
-            ..self
-        }
+        let resource = match self.resource {
+            Some(existing) => Some(existing.merge(&resource)),
+            None => Some(resource),
+        };
+
+        LoggerProviderBuilder { resource, ..self }
     }
 
     /// Create a new provider from this configuration.
@@ -712,6 +717,35 @@ mod tests {
         assert_eq!(scoped_logger.instrumentation_scope().name(), "");
     }
 
+    #[test]
+    fn with_resource_multiple_calls_ensure_additive() {
+        let builder = SdkLoggerProvider::builder()
+            .with_resource(Resource::new(vec![KeyValue::new("key1", "value1")]))
+            .with_resource(Resource::new(vec![KeyValue::new("key2", "value2")]))
+            .with_resource(
+                Resource::builder_empty()
+                    .with_schema_url(vec![], "http://example.com")
+                    .build(),
+            )
+            .with_resource(Resource::new(vec![KeyValue::new("key3", "value3")]));
+
+        let resource = builder.resource.unwrap();
+
+        assert_eq!(
+            resource.get(&Key::from_static_str("key1")),
+            Some(Value::from("value1"))
+        );
+        assert_eq!(
+            resource.get(&Key::from_static_str("key2")),
+            Some(Value::from("value2"))
+        );
+        assert_eq!(
+            resource.get(&Key::from_static_str("key3")),
+            Some(Value::from("value3"))
+        );
+        assert_eq!(resource.schema_url(), Some("http://example.com"));
+    }
+
     #[derive(Debug)]
     pub(crate) struct LazyLogProcessor {
         shutdown_called: Arc<Mutex<bool>>,

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -232,7 +232,8 @@ impl MeterProviderBuilder {
     /// with all [Meter]s the [MeterProvider] will create.
     ///
     /// By default, if this option is not used, the default [Resource] will be used.
-    /// Note that the calls to this method are additive, each call merges the provided
+    ///
+    /// *Note*: Calls to this method are additive, each call merges the provided
     /// resource with the previous one.
     ///
     /// [Meter]: opentelemetry::metrics::Meter

opentelemetry-sdk/src/trace/provider.rs

@@ -293,6 +293,7 @@ impl opentelemetry::trace::TracerProvider for SdkTracerProvider {
 pub struct TracerProviderBuilder {
     processors: Vec<Box<dyn SpanProcessor>>,
     config: crate::trace::Config,
+    resource: Option<Resource>,
 }
 
 impl TracerProviderBuilder {
@@ -410,18 +411,28 @@ impl TracerProviderBuilder {
     ///
     /// By default, if this option is not used, the default [Resource] will be used.
     ///
+    /// *Note*: Calls to this method are additive, each call merges the provided
+    /// resource with the previous one.
+    ///
     /// [Tracer]: opentelemetry::trace::Tracer
     pub fn with_resource(self, resource: Resource) -> Self {
-        TracerProviderBuilder {
-            config: self.config.with_resource(resource),
-            ..self
-        }
+        let resource = match self.resource {
+            Some(existing) => Some(existing.merge(&resource)),
+            None => Some(resource),
+        };
+
+        TracerProviderBuilder { resource, ..self }
     }
 
     /// Create a new provider from this configuration.
     pub fn build(self) -> SdkTracerProvider {
         let mut config = self.config;
 
+        // Now, we can update the config with the resource.
+        if let Some(resource) = self.resource {
+            config = config.with_resource(resource);
+        };
+
         // Standard config will contain an owned [`Resource`] (either sdk default or use supplied)
         // we can optimize the common case with a static ref to avoid cloning the underlying
         // resource data for each span.
@@ -462,8 +473,8 @@ mod tests {
         SERVICE_NAME, TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_NAME, TELEMETRY_SDK_VERSION,
     };
     use crate::trace::provider::TracerProviderInner;
-    use crate::trace::SpanData;
     use crate::trace::{Config, Span, SpanProcessor};
+    use crate::trace::{SdkTracerProvider, SpanData};
     use crate::Resource;
     use opentelemetry::trace::{Tracer, TracerProvider};
     use opentelemetry::{Context, Key, KeyValue, Value};
@@ -730,6 +741,38 @@ mod tests {
         assert!(test_tracer_1.provider().is_shutdown());
     }
 
+    #[test]
+    fn with_resource_multiple_calls_ensure_additive() {
+        let resource = SdkTracerProvider::builder()
+            .with_resource(Resource::new(vec![KeyValue::new("key1", "value1")]))
+            .with_resource(Resource::new(vec![KeyValue::new("key2", "value2")]))
+            .with_resource(
+                Resource::builder_empty()
+                    .with_schema_url(vec![], "http://example.com")
+                    .build(),
+            )
+            .with_resource(Resource::new(vec![KeyValue::new("key3", "value3")]))
+            .build()
+            .inner
+            .config
+            .resource
+            .to_owned();
+
+        assert_eq!(
+            resource.get(&Key::from_static_str("key1")),
+            Some(Value::from("value1"))
+        );
+        assert_eq!(
+            resource.get(&Key::from_static_str("key2")),
+            Some(Value::from("value2"))
+        );
+        assert_eq!(
+            resource.get(&Key::from_static_str("key3")),
+            Some(Value::from("value3"))
+        );
+        assert_eq!(resource.schema_url(), Some("http://example.com"));
+    }
+
     #[derive(Debug)]
     struct CountingShutdownProcessor {
         shutdown_count: Arc<AtomicU32>,