feat: add user agent header to HTTP requests (#473)

* chore: add coverage artifacts to gitignore

* test(redisctl): add unit tests for async_utils pure functions

Add comprehensive unit tests for async operation utilities:
- Task state detection (completed, failed, cancelled, in-progress)
- Task state formatting with visual indicators
- Task details parsing from various API response formats
- Error handling for nested and alternative field names

Coverage: 22 new tests for critical polling/async logic
Related to #462

* feat: add user agent header to HTTP requests

Add configurable User-Agent header support to both Cloud and Enterprise
API clients for request tracking purposes.

- Add user_agent field to CloudClientBuilder with default redis-cloud/{version}
- Add user_agent field to EnterpriseClientBuilder with default redis-enterprise/{version}
- Configure redisctl CLI to use redisctl/{version} as user agent
- Set User-Agent via default_headers() on reqwest client builder

Author: joshrotenberg

crates/redis-cloud/src/client.rs

@@ -8,10 +8,14 @@
 
 use crate::{CloudError as RestError, Result};
 use reqwest::Client;
+use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT};
 use serde::Serialize;
 use std::sync::Arc;
 use tracing::{debug, instrument, trace};
 
+/// Default user agent for the Redis Cloud client
+const DEFAULT_USER_AGENT: &str = concat!("redis-cloud/", env!("CARGO_PKG_VERSION"));
+
 /// Builder for constructing a CloudClient with custom configuration
 ///
 /// Provides a fluent interface for configuring API credentials, base URL, timeouts,
@@ -43,6 +47,7 @@ pub struct CloudClientBuilder {
     api_secret: Option<String>,
     base_url: String,
     timeout: std::time::Duration,
+    user_agent: String,
 }
 
 impl Default for CloudClientBuilder {
@@ -52,6 +57,7 @@ impl Default for CloudClientBuilder {
             api_secret: None,
             base_url: "https://api.redislabs.com/v1".to_string(),
             timeout: std::time::Duration::from_secs(30),
+            user_agent: DEFAULT_USER_AGENT.to_string(),
         }
     }
 }
@@ -86,6 +92,16 @@ impl CloudClientBuilder {
         self
     }
 
+    /// Set the user agent string for HTTP requests
+    ///
+    /// The default user agent is `redis-cloud/{version}`.
+    /// This can be overridden to identify specific clients, for example:
+    /// `redisctl/1.2.3` or `my-app/1.0.0`.
+    pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
+        self.user_agent = user_agent.into();
+        self
+    }
+
     /// Build the client
     pub fn build(self) -> Result<CloudClient> {
         let api_key = self
@@ -95,8 +111,16 @@ impl CloudClientBuilder {
             .api_secret
             .ok_or_else(|| RestError::ConnectionError("API secret is required".to_string()))?;
 
+        let mut default_headers = HeaderMap::new();
+        default_headers.insert(
+            USER_AGENT,
+            HeaderValue::from_str(&self.user_agent)
+                .map_err(|e| RestError::ConnectionError(format!("Invalid user agent: {}", e)))?,
+        );
+
         let client = Client::builder()
             .timeout(self.timeout)
+            .default_headers(default_headers)
             .build()
             .map_err(|e| RestError::ConnectionError(e.to_string()))?;
 

crates/redis-enterprise/src/client.rs

@@ -1,12 +1,16 @@
 //! REST API client implementation
 
 use crate::error::{RestError, Result};
+use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT};
 use reqwest::{Client, Response};
 use serde::{Serialize, de::DeserializeOwned};
 use std::sync::Arc;
 use std::time::Duration;
 use tracing::{debug, trace};
 
+/// Default user agent for the Redis Enterprise client
+const DEFAULT_USER_AGENT: &str = concat!("redis-enterprise/", env!("CARGO_PKG_VERSION"));
+
 // Legacy alias for backwards compatibility during migration
 pub type RestConfig = EnterpriseClientBuilder;
 
@@ -18,6 +22,7 @@ pub struct EnterpriseClientBuilder {
     password: Option<String>,
     timeout: Duration,
     insecure: bool,
+    user_agent: String,
 }
 
 impl Default for EnterpriseClientBuilder {
@@ -28,6 +33,7 @@ impl Default for EnterpriseClientBuilder {
             password: None,
             timeout: Duration::from_secs(30),
             insecure: false,
+            user_agent: DEFAULT_USER_AGENT.to_string(),
         }
     }
 }
@@ -68,14 +74,32 @@ impl EnterpriseClientBuilder {
         self
     }
 
+    /// Set the user agent string for HTTP requests
+    ///
+    /// The default user agent is `redis-enterprise/{version}`.
+    /// This can be overridden to identify specific clients, for example:
+    /// `redisctl/1.2.3` or `my-app/1.0.0`.
+    pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
+        self.user_agent = user_agent.into();
+        self
+    }
+
     /// Build the client
     pub fn build(self) -> Result<EnterpriseClient> {
         let username = self.username.unwrap_or_default();
         let password = self.password.unwrap_or_default();
 
+        let mut default_headers = HeaderMap::new();
+        default_headers.insert(
+            USER_AGENT,
+            HeaderValue::from_str(&self.user_agent)
+                .map_err(|e| RestError::ConnectionError(format!("Invalid user agent: {}", e)))?,
+        );
+
         let client_builder = Client::builder()
             .timeout(self.timeout)
-            .danger_accept_invalid_certs(self.insecure);
+            .danger_accept_invalid_certs(self.insecure)
+            .default_headers(default_headers);
 
         let client = client_builder
             .build()

crates/redisctl/src/connection.rs

@@ -5,6 +5,9 @@ use anyhow::Context;
 use redisctl_config::{Config, DeploymentType};
 use tracing::{debug, info, trace};
 
+/// User agent string for redisctl HTTP requests
+const REDISCTL_USER_AGENT: &str = concat!("redisctl/", env!("CARGO_PKG_VERSION"));
+
 /// Connection manager for creating authenticated clients
 #[allow(dead_code)] // Used by binary target
 #[derive(Clone)]
@@ -161,6 +164,7 @@ impl ConnectionManager {
             .api_key(&final_api_key)
             .api_secret(&final_api_secret)
             .base_url(&final_api_url)
+            .user_agent(REDISCTL_USER_AGENT)
             .build()
             .context("Failed to create Redis Cloud client")?;
 
@@ -306,7 +310,8 @@ impl ConnectionManager {
         // Build the Enterprise client
         let mut builder = redis_enterprise::EnterpriseClient::builder()
             .base_url(&final_url)
-            .username(&final_username);
+            .username(&final_username)
+            .user_agent(REDISCTL_USER_AGENT);
 
         // Add password if provided
         if let Some(ref password) = final_password {