Feat/add resource builder

examples/metrics-advanced/src/main.rs

@@ -49,13 +49,14 @@ fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
         .with_temporality(Temporality::Delta)
         .build();
 
+    let resource = Resource::builder()
+        .with_key_value(KeyValue::new("service.name", "metrics-advanced-example"))
+        .build();
+
     let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
     let provider = SdkMeterProvider::builder()
         .with_reader(reader)
-        .with_resource(Resource::new([KeyValue::new(
-            "service.name",
-            "metrics-advanced-example",
-        )]))
+        .with_resource(resource)
         .with_view(my_view_rename_and_unit)
         .with_view(my_view_drop_attributes)
         .with_view(my_view_change_aggregation)

opentelemetry-sdk/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## vNext
 
+- Add `ResourceBuilder` for an easy way to create new `Resource`s
 - **DEPRECATED**:
   - `trace::Config` methods are moving onto `TracerProvider` Builder to be consistent with other signals. See https://github.com/open-telemetry/opentelemetry-rust/pull/2303 for migration guide.
     `trace::Config` is scheduled to be removed from public API in `v0.28.0`.

opentelemetry-sdk/src/resource/builder.rs

@@ -0,0 +1,108 @@
+use std::time::Duration;
+
+use opentelemetry::{KeyValue, Value};
+
+use super::{Resource, ResourceDetector, SERVICE_NAME};
+
+/// Builder to allow easy composition of a Resource
+#[derive(Debug, Default)]
+pub struct ResourceBuilder {
+    resource: Resource,
+}
+
+impl ResourceBuilder {
+    /// Create ResourceBuilder with an empty [Resource].
+    pub fn new_empty() -> Self {
+        ResourceBuilder {
+            resource: Resource::empty(),
+        }
+    }
+
+    /// Create ResourceBuilder with a default [Resource].
+    pub fn new_default() -> Self {
+        ResourceBuilder {
+            resource: Resource::default(),
+        }
+    }
+
+    /// Add a single [ResourceDetector] to your resource.
+    pub fn with_detector(self, detector: Box<dyn ResourceDetector>) -> Self {
+        self.with_detectors(vec![detector])
+    }
+
+    /// Add multiple [ResourceDetector] to your resource.
+    pub fn with_detectors(mut self, detectors: Vec<Box<dyn ResourceDetector>>) -> Self {
+        self.resource = self
+            .resource
+            .merge(&Resource::from_detectors(Duration::from_secs(0), detectors));
+        self
+    }
+
+    /// Add a [KeyValue] to the resource.
+    pub fn with_key_value(self, kv: KeyValue) -> Self {
+        self.with_key_values(vec![kv])
+    }
+
+    /// Add an [Attribute] to your resource for "service.name"
+    pub fn with_service_name<V>(self, service_name: V) -> Self
+    where
+        V: Into<Value>,
+    {
+        self.with_key_value(KeyValue::new(SERVICE_NAME, service_name))
+    }
+
+    /// Add multiple [KeyValue]s to the resource.
+    pub fn with_key_values<T: IntoIterator<Item = KeyValue>>(mut self, kvs: T) -> Self {
+        self.resource = self.resource.merge(&Resource::new(kvs));
+        self
+    }
+
+    /// Create a [Resource] with the options provided to the [ResourceBuilder].
+    pub fn build(self) -> Resource {
+        self.resource
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use opentelemetry::KeyValue;
+
+    use crate::resource::EnvResourceDetector;
+
+    use super::*;
+
+    #[test]
+    fn detect_resource() {
+        temp_env::with_vars(
+            [
+                (
+                    "OTEL_RESOURCE_ATTRIBUTES",
+                    Some("key=value, k = v , a= x, a=z"),
+                ),
+                ("IRRELEVANT", Some("20200810")),
+            ],
+            || {
+                let resource = Resource::builder()
+                    .with_detector(Box::new(EnvResourceDetector::new()))
+                    .with_key_value(KeyValue::new("test1", "test_value"))
+                    .with_key_values(vec![
+                        KeyValue::new("test1", "test_value1"),
+                        KeyValue::new("test2", "test_value2"),
+                    ])
+                    .build();
+
+                assert_eq!(
+                    resource,
+                    Resource::new(vec![
+                        KeyValue::new("key", "value"),
+                        KeyValue::new("test1", "test_value1"),
+                        KeyValue::new("test2", "test_value2"),
+                        KeyValue::new("k", "v"),
+                        KeyValue::new("a", "x"),
+                        KeyValue::new("a", "z"),
+                    ])
+                )
+            },
+        )
+    }
+}

opentelemetry-sdk/src/resource/mod.rs

@@ -20,12 +20,14 @@
 //!
 //! The OS and Process resource detectors are packaged separately in the
 //! [`opentelemetry-resource-detector` crate](https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-resource-detectors).
+mod builder;
 mod env;
 mod telemetry;
 
 mod attributes;
 pub(crate) use attributes::*;
 
+pub use builder::ResourceBuilder;
 pub use env::EnvResourceDetector;
 pub use env::SdkProvidedResourceDetector;
 pub use telemetry::TelemetryResourceDetector;
@@ -66,6 +68,22 @@
 }
 
 impl Resource {
+    /// Creates a Builder that allows you to configure multiple aspects of the Resource.
+    ///
+    /// If you want to start from a [Resource::default()] see [Resource::builder_default()].
+    ///
+    /// Starts with a [Resource::empty()].
+    pub fn builder() -> ResourceBuilder {
+        ResourceBuilder::new_empty()
+    }
+
+    /// Creates a Builder that allows you to configure multiple aspects of the Resource.
+    ///
+    /// Starts with a [Resource::default()].
+    pub fn builder_default() -> ResourceBuilder {
+        ResourceBuilder::new_default()
+    }
+
     /// Creates an empty resource.
     /// This is the basic constructor that initializes a resource with no attributes and no schema URL.
     pub fn empty() -> Self {