feat: add possibility to add custom_attributes to traces, metrics and logs (#1248)

Author: alvarocabanas

agent-control/src/instrumentation/config/otel.rs

@@ -55,6 +55,9 @@ pub struct OtelConfig {
     /// serde serialization and deserialization.
     #[serde(skip)]
     pub(crate) proxy: ProxyConfig,
+    /// Custom attributes to be added to all traces/metrics.
+    #[serde(default)]
+    pub(crate) custom_attributes: HashMap<String, String>,
 }
 
 fn default_insecure_level() -> String {
@@ -67,6 +70,14 @@ impl OtelConfig {
         Self { proxy, ..self }
     }
 
+    /// Returns a new configuration including custom_attributes
+    pub fn with_custom_attributes(self, custom_attributes: HashMap<String, String>) -> Self {
+        Self {
+            custom_attributes,
+            ..self
+        }
+    }
+
     /// Returns the otel endpoint to report traces to.
     pub(crate) fn traces_endpoint(&self) -> String {
         self.target_endpoint(TRACES_SUFFIX)
@@ -193,6 +204,9 @@ insecure_level: "newrelic_agent_control=info,off"
 endpoint: https://otlp.nr-data.net:4318
 headers: {}
 client_timeout: 10s
+custom_attributes:
+    cluster_name: "test"
+    environment: production
 metrics:
   enabled: true
   interval: 120s
@@ -224,6 +238,7 @@ logs:
                 headers: Default::default(),
                 client_timeout: Default::default(),
                 proxy: Default::default(),
+                custom_attributes: Default::default(),
             }
         }
     }

agent-control/src/instrumentation/tracing_layers/otel.rs

@@ -3,23 +3,20 @@ use crate::http::config::HttpConfig;
 use crate::instrumentation::config::otel::OtelConfig;
 use crate::instrumentation::tracing::LayerBox;
 use opentelemetry::trace::TracerProvider;
+use opentelemetry::KeyValue;
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_http::HttpClient as OtelHttpClient;
 use opentelemetry_otlp::{ExporterBuildError, WithExportConfig, WithHttpConfig};
 use opentelemetry_sdk::logs::{BatchLogProcessor, SdkLoggerProvider};
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::trace::{BatchSpanProcessor, SdkTracerProvider};
 use opentelemetry_sdk::Resource;
-use std::sync::LazyLock;
 use thiserror::Error;
 use tracing_opentelemetry::MetricsLayer;
 use tracing_subscriber::{EnvFilter, Layer};
 
 const TRACER_NAME: &str = "agent-control-self-instrumentation";
 
-static RESOURCE: LazyLock<Resource> =
-    LazyLock::new(|| Resource::builder().with_service_name(TRACER_NAME).build());
-
 /// Enumerates the possible error building OpenTelemetry providers.
 #[derive(Debug, Error)]
 pub enum OtelBuildError {
@@ -64,23 +61,40 @@ impl OtelLayers {
     where
         C: OtelHttpClient + Send + Sync + Clone + 'static,
     {
-        let traces_provider = config
-            .traces
-            .enabled
-            .then(|| Self::traces_provider(client.clone(), config))
-            .transpose()?;
-
-        let metrics_provider = config
-            .metrics
-            .enabled
-            .then(|| Self::metrics_provider(client.clone(), config))
-            .transpose()?;
-
-        let logs_provider = config
-            .logs
-            .enabled
-            .then(|| Self::logs_provider(client, config))
-            .transpose()?;
+        let mut traces_provider = None;
+        let mut metrics_provider = None;
+        let mut logs_provider = None;
+
+        if config.traces.enabled || config.metrics.enabled || config.logs.enabled {
+            let attributes: Vec<KeyValue> = config
+                .custom_attributes
+                .iter()
+                .map(|(k, v)| KeyValue::new(k.clone(), v.clone()))
+                .collect();
+
+            let resource = Resource::builder()
+                .with_service_name(TRACER_NAME)
+                .with_attributes(attributes)
+                .build();
+
+            traces_provider = config
+                .traces
+                .enabled
+                .then(|| Self::traces_provider(client.clone(), config, resource.clone()))
+                .transpose()?;
+
+            metrics_provider = config
+                .metrics
+                .enabled
+                .then(|| Self::metrics_provider(client.clone(), config, resource.clone()))
+                .transpose()?;
+
+            logs_provider = config
+                .logs
+                .enabled
+                .then(|| Self::logs_provider(client, config, resource))
+                .transpose()?;
+        }
 
         let filter = EnvFilter::builder()
             .parse(&config.insecure_level)
@@ -100,6 +114,7 @@ impl OtelLayers {
     fn traces_provider<C>(
         client: C,
         config: &OtelConfig,
+        resource: Resource,
     ) -> Result<SdkTracerProvider, OtelBuildError>
     where
         C: OtelHttpClient + Send + Sync + 'static,
@@ -117,13 +132,14 @@ impl OtelLayers {
 
         Ok(SdkTracerProvider::builder()
             .with_span_processor(batch_processor)
-            .with_resource(RESOURCE.clone())
+            .with_resource(resource)
             .build())
     }
 
     fn metrics_provider<C>(
         client: C,
         config: &OtelConfig,
+        resource: Resource,
     ) -> Result<SdkMeterProvider, OtelBuildError>
     where
         C: OtelHttpClient + Send + Sync + 'static,
@@ -141,11 +157,15 @@ impl OtelLayers {
 
         Ok(SdkMeterProvider::builder()
             .with_reader(periodic_reader)
-            .with_resource(RESOURCE.clone())
+            .with_resource(resource)
             .build())
     }
 
-    fn logs_provider<C>(client: C, config: &OtelConfig) -> Result<SdkLoggerProvider, OtelBuildError>
+    fn logs_provider<C>(
+        client: C,
+        config: &OtelConfig,
+        resource: Resource,
+    ) -> Result<SdkLoggerProvider, OtelBuildError>
     where
         C: OtelHttpClient + Send + Sync + 'static,
     {
@@ -162,7 +182,7 @@ impl OtelLayers {
 
         Ok(SdkLoggerProvider::builder()
             .with_log_processor(batch_processor)
-            .with_resource(RESOURCE.clone())
+            .with_resource(resource)
             .build())
     }
 
@@ -190,6 +210,7 @@ impl OtelLayers {
 #[cfg(test)]
 mod tests {
     use http::Response;
+    use opentelemetry_sdk::Resource;
     use tracing::{debug, info, trace};
     use tracing_subscriber::layer::SubscriberExt;
     use tracing_subscriber::EnvFilter;
@@ -232,6 +253,7 @@ mod tests {
                 },
                 ..Default::default()
             },
+            Resource::builder().build(),
         )
         .unwrap();
 

docs/CONFIG.md

@@ -102,6 +102,7 @@ self_instrumentation:
     endpoint: https://otlp.nr-data.net:4318 # HTTPS endpoint to report instrumentation to.
     headers: {} # Headers that will be included in any request to the endpoint
     client_timeout: 10s # Timeout for performing requests, defaults to 30s.
+    custom_attributes: {} # Attributes to be decorated in all metrics, traces and logs
     metrics:
       enabled: true # Defaults to false.
       interval: 120s # Interval to report metrics, it defaults to 60s.