fix(libdd-traceutils): Update cloud environment detection logic for Serverless [SVLS-8799] (#1857)

kathiehuang · web-flow · commit d60d0a4bc7df · 2026-04-13T20:33:10.000Z
# What does this PR do? - Updates cloud environment detection logic to be more specific and aligned with the Serverless Compatibility Layers ([example](https://github.com/DataDog/datadog-serverless-compat-js/blob/7e68fce247490f721995c26def258b539a6d788c/src/index.ts#L18-L45)) by requiring multiple cloud-specific environment variables to identify each platform - Adds structured logging: debug when one environment is detected, error when zero or multiple are detected, and error when a platform is detected but its name variable is missing - Return None when multiple conflicting environments are detected instead of silently returning the first match - Adds unit tests covering all detection paths, missing name vars, single-var-only cases, multiple environments, and no environment Platform | Before | After -- | -- | -- AWS Lambda | AWS_LAMBDA_FUNCTION_NAME | AWS_LAMBDA_INITIALIZATION_TYPE (detect) + AWS_LAMBDA_FUNCTION_NAME (name) Azure Functions | WEBSITE_SITE_NAME | FUNCTIONS_EXTENSION_VERSION + FUNCTIONS_WORKER_RUNTIME (detect) + WEBSITE_SITE_NAME (name) GCP Cloud Functions Gen 1 | FUNCTION_NAME | FUNCTION_NAME + GCP_PROJECT GCP Cloud Run Functions Gen 2 | K_SERVICE | K_SERVICE + FUNCTION_TARGET Azure Spring Apps | ASCSVCRT_SPRING__APPLICATION__NAME | unchanged # Motivation A customer instrumenting a Java Azure Function had set `FUNCTION_NAME` as an environment variable. This led the current libdatadog logic to return `EnvironmentType::CloudFunction`, which led to [this](https://github.com/DataDog/serverless-components/blob/96ab942a20979aeb8640214f027cb94e5da7b6fe/crates/datadog-trace-agent/src/env_verifier.rs#L96) being called in serverless-components which returned an error after running a Google-specific metadata check. As a result, we want the environment detection logic to check multiple cloud-specific env vars at once. # Additional Notes Once this PR is merged, we plan to make a new PR in serverless-components to update the libdatadog commit hash. # How to test the change? Unit tests: Run `cargo test -p libdd-trace-utils config_utils` 1. Use git log to find this PR's most recent commit hash 2. Clone [serverless-components](https://github.com/DataDog/serverless-components/tree/main) and update the commit hash in [datadog-trace-agent/Cargo.toml](https://github.com/DataDog/serverless-components/blob/main/crates/datadog-trace-agent/Cargo.toml) everywhere that libdatadog is used 3. Follow the instructions in the [Serverless Compatibility Layer docs](https://datadoghq.atlassian.net/wiki/spaces/SLS/pages/2977497119/Serverless+Compatibility+Layer) to deploy sample apps 4. Turn `DD_LOG_LEVEL=DEBUG` in GCP/Azure functions to make sure the correct environment is detected 5. Set `FUNCTION_NAME` as an env var in Azure Functions to make sure it isn't identified as a Google Cloud Function 6. To test with Google Cloud Gen 1, deploy a gen1 app and use the .whl from `serverless-compat-self-monitoring/azure_functions/code/compat/python/datadog_serverless_compat-0.0.0-py3-none-any.whl` and drop it in the root of the app. Replace `datadog-serverless-compat` in `requirements.txt` to this file name. Deployed a Java Azure Function without this change with `FUNCTION_NAME=myfunction` and got the same error: <img width="591" height="224" alt="image" src="https://github.com/user-attachments/assets/69a7db4a-7fc3-4532-94c8-f6d8d8a853f4" /> Redeployed the Azure Function with this change. The error disappeared and we're getting traces: <img width="687" height="270" alt="image" src="https://github.com/user-attachments/assets/5e087889-3345-4fb4-a514-124194965613" /> Also deployed a Python Google Cloud Function Gen 1 with this change. Interestingly, it's getting detected as Gen 2. <img width="706" height="279" alt="image" src="https://github.com/user-attachments/assets/c0db4123-683e-4234-bda7-5a8efbc36685" /> I printed out the env vars and `FUNCTION_TARGET` and `K_SERVICE` are being set, but not `FUNCTION_NAME` and `GCP_PROJECT`: ``` DEFAULT 2026-04-09T21:52:43.186346Z [resource.labels.functionName: gen1-func-envvars] [labels.executionId: j3djq5xx9qqk] FUNCTION_NAME=NOT SET DEFAULT 2026-04-09T21:52:43.186349Z [resource.labels.functionName: gen1-func-envvars] [labels.executionId: j3djq5xx9qqk] GCP_PROJECT=NOT SET DEFAULT 2026-04-09T21:52:43.186393Z [resource.labels.functionName: gen1-func-envvars] [labels.executionId: j3djq5xx9qqk] FUNCTION_TARGET=main DEFAULT 2026-04-09T21:52:43.186399Z [resource.labels.functionName: gen1-func-envvars] [labels.executionId: j3djq5xx9qqk] K_SERVICE=gen1-func-envvars ``` Serverless compatibility layers that don't check `FUNCTION_TARGET` or `K_SERVICE` should be updated (e.g. [serverless-compat-java](https://github.com/DataDog/datadog-serverless-compat-java/blob/a1bceb25ce55cd811938e89d750b4f10319c4336/src/main/java/com/datadog/ServerlessCompatAgent.java#L64)) to have the same logic as other runtimes ([serverless-compat-py](https://github.com/DataDog/datadog-serverless-compat-py/blob/71b0cb39ceff4bb6fc5ed822c1545ecdd2fd47fa/datadog_serverless_compat/main.py#L34)) To update: - serverless-compat-java - serverless-compat-dotnet Co-authored-by: kathie.huang <kathie.huang@datadoghq.com>
diff --git a/libdd-trace-utils/src/config_utils.rs b/libdd-trace-utils/src/config_utils.rs
@@ -3,33 +3,71 @@
 
 use crate::trace_utils;
 use std::env;
+use tracing::{debug, error};
 
 pub const PROD_INTAKE_SUBDOMAIN: &str = "trace.agent";
 
 const TRACE_INTAKE_ROUTE: &str = "/api/v0.2/traces";
 const TRACE_STATS_INTAKE_ROUTE: &str = "/api/v0.2/stats";
 
 pub fn read_cloud_env() -> Option<(String, trace_utils::EnvironmentType)> {
-    if let Ok(res) = env::var("AWS_LAMBDA_FUNCTION_NAME") {
-        return Some((res, trace_utils::EnvironmentType::LambdaFunction));
+    let mut detected: Vec<(String, trace_utils::EnvironmentType)> = Vec::new();
+
+    if env::var("AWS_LAMBDA_INITIALIZATION_TYPE").is_ok() {
+        match env::var("AWS_LAMBDA_FUNCTION_NAME") {
+            Ok(name) => detected.push((name, trace_utils::EnvironmentType::LambdaFunction)),
+            Err(_) => {
+                error!("AWS Lambda environment detected but AWS_LAMBDA_FUNCTION_NAME is not set");
+            }
+        }
     }
-    if let Ok(res) = env::var("K_SERVICE") {
-        // Set by Google Cloud Functions for newer runtimes
-        return Some((res, trace_utils::EnvironmentType::CloudFunction));
+
+    if env::var("FUNCTIONS_EXTENSION_VERSION").is_ok()
+        && env::var("FUNCTIONS_WORKER_RUNTIME").is_ok()
+    {
+        match env::var("WEBSITE_SITE_NAME") {
+            Ok(name) => detected.push((name, trace_utils::EnvironmentType::AzureFunction)),
+            Err(_) => {
+                error!("Azure Functions environment detected but WEBSITE_SITE_NAME is not set");
+            }
+        }
     }
-    if let Ok(res) = env::var("FUNCTION_NAME") {
+
+    if let (Ok(name), Ok(_)) = (env::var("K_SERVICE"), env::var("FUNCTION_TARGET")) {
+        // Set by Google Cloud Functions for newer runtimes
+        detected.push((name, trace_utils::EnvironmentType::CloudFunction));
+    } else if let (Ok(name), Ok(_)) = (env::var("FUNCTION_NAME"), env::var("GCP_PROJECT")) {
         // Set by Google Cloud Functions for older runtimes
-        return Some((res, trace_utils::EnvironmentType::CloudFunction));
+        detected.push((name, trace_utils::EnvironmentType::CloudFunction));
     }
-    if let Ok(res) = env::var("WEBSITE_SITE_NAME") {
-        // Set by Azure Functions
-        return Some((res, trace_utils::EnvironmentType::AzureFunction));
-    }
-    if let Ok(res) = env::var("ASCSVCRT_SPRING__APPLICATION__NAME") {
+
+    if let Ok(name) = env::var("ASCSVCRT_SPRING__APPLICATION__NAME") {
         // Set by Azure Spring Apps
-        return Some((res, trace_utils::EnvironmentType::AzureSpringApp));
+        detected.push((name, trace_utils::EnvironmentType::AzureSpringApp));
+    }
+
+    match detected.len() {
+        0 => {
+            error!("No cloud environment detected");
+            None
+        }
+        1 => {
+            let (ref name, ref env_type) = detected[0];
+            debug!("Cloud environment detected: {env_type:?} ({name})");
+            detected.into_iter().next()
+        }
+        _ => {
+            let env_names: Vec<String> = detected
+                .iter()
+                .map(|(name, env_type)| format!("{env_type:?}({name})"))
+                .collect();
+            error!(
+                "Multiple cloud environments detected: {}",
+                env_names.join(", ")
+            );
+            None
+        }
     }
-    None
 }
 
 pub fn trace_intake_url(site: &str) -> String {
@@ -51,3 +89,195 @@ pub fn trace_stats_url_prefixed(endpoint_prefix: &str) -> String {
 fn construct_trace_intake_url(prefix: &str, route: &str) -> String {
     format!("https://{PROD_INTAKE_SUBDOMAIN}.{prefix}{route}")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    // Mutex to ensure environment variable tests run sequentially
+    static ENV_TEST_LOCK: Mutex<()> = Mutex::new(());
+
+    fn clear_all_env_vars() {
+        unsafe {
+            env::remove_var("AWS_LAMBDA_INITIALIZATION_TYPE");
+            env::remove_var("AWS_LAMBDA_FUNCTION_NAME");
+            env::remove_var("FUNCTIONS_EXTENSION_VERSION");
+            env::remove_var("FUNCTIONS_WORKER_RUNTIME");
+            env::remove_var("WEBSITE_SITE_NAME");
+            env::remove_var("FUNCTION_NAME");
+            env::remove_var("GCP_PROJECT");
+            env::remove_var("K_SERVICE");
+            env::remove_var("FUNCTION_TARGET");
+            env::remove_var("ASCSVCRT_SPRING__APPLICATION__NAME");
+        }
+    }
+
+    #[test]
+    fn test_aws_lambda_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("AWS_LAMBDA_INITIALIZATION_TYPE", "on-demand");
+            env::set_var("AWS_LAMBDA_FUNCTION_NAME", "my-function");
+        }
+        let result = read_cloud_env();
+        assert_eq!(
+            result,
+            Some((
+                "my-function".to_string(),
+                trace_utils::EnvironmentType::LambdaFunction
+            ))
+        );
+    }
+
+    #[test]
+    fn test_aws_lambda_missing_function_name() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("AWS_LAMBDA_INITIALIZATION_TYPE", "on-demand") };
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_aws_lambda_not_detected_without_init_type() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("AWS_LAMBDA_FUNCTION_NAME", "my-function") };
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_azure_function_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("FUNCTIONS_EXTENSION_VERSION", "~4");
+            env::set_var("FUNCTIONS_WORKER_RUNTIME", "java");
+            env::set_var("WEBSITE_SITE_NAME", "my-azure-app");
+        }
+        let result = read_cloud_env();
+        assert_eq!(
+            result,
+            Some((
+                "my-azure-app".to_string(),
+                trace_utils::EnvironmentType::AzureFunction
+            ))
+        );
+    }
+
+    #[test]
+    fn test_azure_function_missing_site_name() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("FUNCTIONS_EXTENSION_VERSION", "~4");
+            env::set_var("FUNCTIONS_WORKER_RUNTIME", "java");
+        }
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_azure_function_not_detected_with_only_one_var() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("FUNCTIONS_EXTENSION_VERSION", "~4") };
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_gcp_1st_gen_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("FUNCTION_NAME", "my-gcp-function");
+            env::set_var("GCP_PROJECT", "my-project");
+        }
+        let result = read_cloud_env();
+        assert_eq!(
+            result,
+            Some((
+                "my-gcp-function".to_string(),
+                trace_utils::EnvironmentType::CloudFunction
+            ))
+        );
+    }
+
+    #[test]
+    fn test_gcp_1st_gen_not_detected_without_gcp_project() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("FUNCTION_NAME", "my-gcp-function") };
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_gcp_2nd_gen_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("K_SERVICE", "my-cloud-run-fn");
+            env::set_var("FUNCTION_TARGET", "myHandler");
+        }
+        let result = read_cloud_env();
+        assert_eq!(
+            result,
+            Some((
+                "my-cloud-run-fn".to_string(),
+                trace_utils::EnvironmentType::CloudFunction
+            ))
+        );
+    }
+
+    #[test]
+    fn test_gcp_2nd_gen_not_detected_without_function_target() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("K_SERVICE", "my-cloud-run-fn") };
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_azure_spring_app_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe { env::set_var("ASCSVCRT_SPRING__APPLICATION__NAME", "my-spring-app") };
+        let result = read_cloud_env();
+        assert_eq!(
+            result,
+            Some((
+                "my-spring-app".to_string(),
+                trace_utils::EnvironmentType::AzureSpringApp
+            ))
+        );
+    }
+
+    #[test]
+    fn test_no_environment_detected() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_multiple_environments_returns_none() {
+        let _lock = ENV_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        clear_all_env_vars();
+        unsafe {
+            env::set_var("AWS_LAMBDA_INITIALIZATION_TYPE", "on-demand");
+            env::set_var("AWS_LAMBDA_FUNCTION_NAME", "my-lambda");
+            env::set_var("FUNCTIONS_EXTENSION_VERSION", "~4");
+            env::set_var("FUNCTIONS_WORKER_RUNTIME", "java");
+            env::set_var("WEBSITE_SITE_NAME", "my-azure-app");
+        }
+        let result = read_cloud_env();
+        assert_eq!(result, None);
+    }
+}
