feat: add trace stats computation

crates/datadog-agent-config/Cargo.toml

@@ -9,8 +9,8 @@ path = "mod.rs"
 
 [dependencies]
 figment = { version = "0.10", default-features = false, features = ["yaml", "env"] }
-libdd-trace-obfuscation = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
-libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
+libdd-trace-obfuscation = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
+libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
 log = { version = "0.4", default-features = false }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde-aux = { version = "4.7", default-features = false }

crates/datadog-serverless-compat/Cargo.toml

@@ -11,7 +11,7 @@ windows-pipes = ["datadog-trace-agent/windows-pipes", "dogstatsd/windows-pipes"]
 
 [dependencies]
 datadog-trace-agent = { path = "../datadog-trace-agent" }
-libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
+libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
 datadog-fips = { path = "../datadog-fips", default-features = false }
 dogstatsd = { path = "../dogstatsd", default-features = true }
 reqwest = { version = "0.12.4", default-features = false }

crates/datadog-serverless-compat/src/main.rs

@@ -18,7 +18,8 @@ use zstd::zstd_safe::CompressionLevel;
 
 use datadog_trace_agent::{
     aggregator::TraceAggregator,
-    config, env_verifier, mini_agent, proxy_flusher, stats_flusher, stats_processor,
+    config, env_verifier, mini_agent, proxy_flusher, stats_concentrator_service, stats_flusher,
+    stats_generator, stats_processor,
     trace_flusher::{self, TraceFlusher},
     trace_processor,
 };
@@ -107,6 +108,12 @@ pub async fn main() {
     let https_proxy = env::var("DD_PROXY_HTTPS")
         .or_else(|_| env::var("HTTPS_PROXY"))
         .ok();
+
+    let dd_serverless_stats_computation_enabled =
+        env::var("DD_SERVERLESS_STATS_COMPUTATION_ENABLED")
+            .map(|val| val.to_lowercase() != "false")
+            .unwrap_or(true);
+
     debug!("Starting serverless trace mini agent");
 
     let env_filter = format!("h2=off,hyper=off,rustls=off,{}", log_level);
@@ -132,11 +139,6 @@ pub async fn main() {
 
     let env_verifier = Arc::new(env_verifier::ServerlessEnvVerifier::default());
 
-    let trace_processor = Arc::new(trace_processor::ServerlessTraceProcessor {});
-
-    let stats_flusher = Arc::new(stats_flusher::ServerlessStatsFlusher {});
-    let stats_processor = Arc::new(stats_processor::ServerlessStatsProcessor {});
-
     let config = match config::Config::new() {
         Ok(c) => Arc::new(c),
         Err(e) => {
@@ -145,6 +147,30 @@ pub async fn main() {
         }
     };
 
+    // Initialize stats concentrator service and generator conditionally
+    let (stats_concentrator_handle, stats_generator) = if dd_serverless_stats_computation_enabled {
+        info!("Serverless stats computation enabled");
+        let (stats_concentrator_service, stats_concentrator_handle) =
+            stats_concentrator_service::StatsConcentratorService::new(config.clone());
+        tokio::spawn(stats_concentrator_service.run());
+        let stats_generator = Arc::new(stats_generator::StatsGenerator::new(
+            stats_concentrator_handle.clone(),
+        ));
+        (Some(stats_concentrator_handle), Some(stats_generator))
+    } else {
+        info!("Serverless stats computation disabled");
+        (None, None)
+    };
+
+    let trace_processor = Arc::new(trace_processor::ServerlessTraceProcessor {
+        stats_generator: stats_generator.clone(),
+    });
+
+    let stats_flusher = Arc::new(stats_flusher::ServerlessStatsFlusher {
+        stats_concentrator: stats_concentrator_handle.clone(),
+    });
+    let stats_processor = Arc::new(stats_processor::ServerlessStatsProcessor {});
+
     let trace_aggregator = Arc::new(TokioMutex::new(TraceAggregator::default()));
     let trace_flusher = Arc::new(trace_flusher::ServerlessTraceFlusher::new(
         trace_aggregator,

crates/datadog-trace-agent/Cargo.toml

@@ -24,14 +24,19 @@ async-trait = "0.1.64"
 tracing = { version = "0.1", default-features = false }
 serde = { version = "1.0.145", features = ["derive"] }
 serde_json = "1.0"
-libdd-common = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
-libdd-trace-protobuf = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
-libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad", features = [
+thiserror = { version = "1.0.58", default-features = false }
+libdd-common = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
+libdd-trace-protobuf = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
+libdd-trace-stats = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
+libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49", features = [
     "mini_agent",
 ] }
-libdd-trace-obfuscation = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad" }
+libdd-trace-obfuscation = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49" }
 datadog-fips = { path = "../datadog-fips" }
-reqwest = { version = "0.12.23", features = ["json", "http2"], default-features = false }
+reqwest = { version = "0.12.23", features = [
+    "json",
+    "http2",
+], default-features = false }
 bytes = "1.10.1"
 
 [dev-dependencies]
@@ -40,6 +45,6 @@ serial_test = "2.0.0"
 duplicate = "0.4.1"
 temp-env = "0.3.6"
 tempfile = "3.3.0"
-libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "8c88979985154d6d97c0fc2ca9039682981eacad", features = [
+libdd-trace-utils = { git = "https://github.com/DataDog/libdatadog", rev = "49ba1c9d33734ec3bd8cc5e7e57bb63a1f832c49", features = [
     "test-utils",
 ] }

crates/datadog-trace-agent/src/config.rs

@@ -14,6 +14,7 @@ use libdd_trace_utils::config_utils::{
     trace_stats_url_prefixed,
 };
 use libdd_trace_utils::trace_utils;
+use tracing::debug;
 
 const DEFAULT_APM_RECEIVER_PORT: u16 = 8126;
 const DEFAULT_DOGSTATSD_PORT: u16 = 8125;
@@ -109,6 +110,11 @@ pub struct Config {
     /// timeout for environment verification, in milliseconds
     pub verify_env_timeout_ms: u64,
     pub proxy_url: Option<String>,
+    pub service: Option<String>,
+    pub env: Option<String>,
+    pub version: Option<String>,
+    /// Span tag keys used as second primary tags
+    pub span_derived_primary_tags: Vec<String>,
 }
 
 impl Config {
@@ -212,6 +218,17 @@ impl Config {
             Tags::new()
         };
 
+        let span_derived_primary_tags = match env::var("DD_APM_SPAN_DERIVED_PRIMARY_TAGS") {
+            Ok(env_tags) => parse_json_string_list(&env_tags)?,
+            Err(_) => vec![],
+        };
+        if !span_derived_primary_tags.is_empty() {
+            debug!(
+                "span_derived_primary_tags configured: [{}]",
+                span_derived_primary_tags.join(" ")
+            );
+        }
+
         #[allow(clippy::unwrap_used)]
         Ok(Config {
             app_name: Some(app_name),
@@ -251,10 +268,24 @@ impl Config {
                 .or_else(|_| env::var("HTTPS_PROXY"))
                 .ok(),
             tags,
+            service: env::var("DD_SERVICE").ok(),
+            env: env::var("DD_ENV").ok(),
+            version: env::var("DD_VERSION").ok(),
+            span_derived_primary_tags,
         })
     }
 }
 
+/// Parses a JSON array of strings. Invalid JSON is an error and returns [].
+fn parse_json_string_list(env_tags: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+    serde_json::from_str::<Vec<String>>(env_tags).map_err(|e| {
+        anyhow::anyhow!(
+            "expected a JSON array of strings, e.g. [] or [\"http.url\",\"db.name\"]: {e}"
+        )
+        .into()
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use duplicate::duplicate_item;
@@ -721,6 +752,10 @@ pub mod test_helpers {
             proxy_request_retry_backoff_base_ms: 100,
             verify_env_timeout_ms: 1000,
             proxy_url: None,
+            service: None,
+            env: None,
+            version: None,
+            span_derived_primary_tags: vec![],
         }
     }
 }

crates/datadog-trace-agent/src/lib.rs

@@ -13,7 +13,9 @@ pub mod env_verifier;
 pub mod http_utils;
 pub mod mini_agent;
 pub mod proxy_flusher;
+pub mod stats_concentrator_service;
 pub mod stats_flusher;
+pub mod stats_generator;
 pub mod stats_processor;
 pub mod trace_flusher;
 pub mod trace_processor;

crates/datadog-trace-agent/src/mini_agent.rs

@@ -11,7 +11,7 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Instant;
 use tokio::sync::mpsc::{self, Receiver, Sender};
-use tracing::{debug, error, warn};
+use tracing::{debug, error};
 
 use crate::http_utils::{log_and_create_http_response, verify_request_content_length};
 use crate::proxy_flusher::{ProxyFlusher, ProxyRequest};
@@ -191,14 +191,14 @@ impl MiniAgent {
                 let sentinel = std::path::Path::new(LAMBDA_LITE_SENTINEL_PATH);
                 // SAFETY: LAMBDA_LITE_SENTINEL_PATH is a hard-coded absolute path,
                 // so .parent() always returns Some.
-                if let Some(parent) = sentinel.parent() {
-                    if let Err(e) = tokio::fs::create_dir_all(parent).await {
-                        error!(
-                            "Could not create parent directory for Lambda Lite sentinel \
+                if let Some(parent) = sentinel.parent()
+                    && let Err(e) = tokio::fs::create_dir_all(parent).await
+                {
+                    error!(
+                        "Could not create parent directory for Lambda Lite sentinel \
                              file at {}: {}.",
-                            LAMBDA_LITE_SENTINEL_PATH, e
-                        );
-                    }
+                        LAMBDA_LITE_SENTINEL_PATH, e
+                    );
                 }
                 if let Err(e) = tokio::fs::write(sentinel, b"").await {
                     error!(