Add PAT (Personal Access Token) auth support

- Add set_pat() convenience method on Configuration to set a PAT
  that is used in place of an application key (DD-APPLICATION-KEY header)
- Add DD_PAT env var support, taking precedence over DD_APP_KEY when set
- Update both configuration.rs and configuration.j2 template in sync
- Add unit tests for PAT configuration behavior

Ref: CRED-2150

Author: tausman

.generator/src/generator/templates/configuration.j2

@@ -106,6 +106,19 @@ impl Configuration {
         self.auth_keys.insert(operation_str.to_string(), api_key);
     }
 
+    /// Set a Personal Access Token (PAT) for authentication.
+    /// The PAT is used in place of an application key and is sent
+    /// via the DD-APPLICATION-KEY header.
+    pub fn set_pat(&mut self, pat: String) {
+        self.auth_keys.insert(
+            "appKeyAuth".to_string(),
+            APIKey {
+                key: pat,
+                prefix: "".to_owned(),
+            },
+        );
+    }
+
     pub fn set_proxy_url(&mut self, proxy_url: Option<String>) {
         self.proxy_url = proxy_url;
     }
@@ -149,6 +162,19 @@ impl Default for Configuration {
         {%- endfor %}
         {%- endif %}
 
+        // DD_PAT takes precedence over DD_APP_KEY when set
+        if let Ok(pat) = env::var("DD_PAT") {
+            if !pat.is_empty() {
+                auth_keys.insert(
+                    "appKeyAuth".to_owned(),
+                    APIKey {
+                        key: pat,
+                        prefix: "".to_owned(),
+                    },
+                );
+            }
+        }
+
         Self {
             user_agent: DEFAULT_USER_AGENT.clone(),
             unstable_operations,

src/datadog/configuration.rs

@@ -109,6 +109,19 @@ impl Configuration {
         self.auth_keys.insert(operation_str.to_string(), api_key);
     }
 
+    /// Set a Personal Access Token (PAT) for authentication.
+    /// The PAT is used in place of an application key and is sent
+    /// via the DD-APPLICATION-KEY header.
+    pub fn set_pat(&mut self, pat: String) {
+        self.auth_keys.insert(
+            "appKeyAuth".to_string(),
+            APIKey {
+                key: pat,
+                prefix: "".to_owned(),
+            },
+        );
+    }
+
     pub fn set_proxy_url(&mut self, proxy_url: Option<String>) {
         self.proxy_url = proxy_url;
     }
@@ -363,6 +376,19 @@ impl Default for Configuration {
             },
         );
 
+        // DD_PAT takes precedence over DD_APP_KEY when set
+        if let Ok(pat) = env::var("DD_PAT") {
+            if !pat.is_empty() {
+                auth_keys.insert(
+                    "appKeyAuth".to_owned(),
+                    APIKey {
+                        key: pat,
+                        prefix: "".to_owned(),
+                    },
+                );
+            }
+        }
+
         Self {
             user_agent: DEFAULT_USER_AGENT.clone(),
             unstable_operations,
@@ -1128,3 +1154,113 @@ lazy_static! {
         ])
     };
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    // Mutex to prevent env var tests from interfering with each other
+    static ENV_MUTEX: Mutex<()> = Mutex::new(());
+
+    #[test]
+    fn test_set_pat_overrides_app_key() {
+        let mut config = Configuration::new();
+        config.set_pat("my-pat-token".to_string());
+
+        let app_key = config.auth_keys.get("appKeyAuth").unwrap();
+        assert_eq!(app_key.key, "my-pat-token");
+    }
+
+    #[test]
+    fn test_set_pat_after_construction() {
+        let mut config = Configuration::new();
+        // Set an app key first
+        config.set_auth_key(
+            "appKeyAuth",
+            APIKey {
+                key: "original-app-key".to_string(),
+                prefix: "".to_string(),
+            },
+        );
+        // Now override with PAT
+        config.set_pat("my-pat-token".to_string());
+
+        let app_key = config.auth_keys.get("appKeyAuth").unwrap();
+        assert_eq!(app_key.key, "my-pat-token");
+    }
+
+    #[test]
+    fn test_dd_pat_env_var() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        // Save and clear existing values
+        let old_pat = env::var("DD_PAT").ok();
+        let old_app_key = env::var("DD_APP_KEY").ok();
+
+        env::set_var("DD_PAT", "env-pat-token");
+        env::remove_var("DD_APP_KEY");
+
+        let config = Configuration::default();
+        let app_key = config.auth_keys.get("appKeyAuth").unwrap();
+        assert_eq!(app_key.key, "env-pat-token");
+
+        // Restore env
+        match old_pat {
+            Some(v) => env::set_var("DD_PAT", v),
+            None => env::remove_var("DD_PAT"),
+        }
+        match old_app_key {
+            Some(v) => env::set_var("DD_APP_KEY", v),
+            None => env::remove_var("DD_APP_KEY"),
+        }
+    }
+
+    #[test]
+    fn test_dd_pat_precedence_over_dd_app_key() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        // Save existing values
+        let old_pat = env::var("DD_PAT").ok();
+        let old_app_key = env::var("DD_APP_KEY").ok();
+
+        env::set_var("DD_PAT", "pat-wins");
+        env::set_var("DD_APP_KEY", "app-key-loses");
+
+        let config = Configuration::default();
+        let app_key = config.auth_keys.get("appKeyAuth").unwrap();
+        assert_eq!(app_key.key, "pat-wins");
+
+        // Restore env
+        match old_pat {
+            Some(v) => env::set_var("DD_PAT", v),
+            None => env::remove_var("DD_PAT"),
+        }
+        match old_app_key {
+            Some(v) => env::set_var("DD_APP_KEY", v),
+            None => env::remove_var("DD_APP_KEY"),
+        }
+    }
+
+    #[test]
+    fn test_empty_dd_pat_does_not_override() {
+        let _lock = ENV_MUTEX.lock().unwrap();
+        let old_pat = env::var("DD_PAT").ok();
+        let old_app_key = env::var("DD_APP_KEY").ok();
+
+        env::set_var("DD_PAT", "");
+        env::set_var("DD_APP_KEY", "my-app-key");
+
+        let config = Configuration::default();
+        let app_key = config.auth_keys.get("appKeyAuth").unwrap();
+        assert_eq!(app_key.key, "my-app-key");
+
+        // Restore env
+        match old_pat {
+            Some(v) => env::set_var("DD_PAT", v),
+            None => env::remove_var("DD_PAT"),
+        }
+        match old_app_key {
+            Some(v) => env::set_var("DD_APP_KEY", v),
+            None => env::remove_var("DD_APP_KEY"),
+        }
+    }
+}