hyperi-rustlib 2.5.1

Opinionated Rust framework for high-throughput data pipelines at PB scale. Auto-wiring config, logging, metrics, tracing, health, and graceful shutdown — built from many years of production infrastructure experience.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// Project:   hyperi-rustlib
// File:      src/http_client/config.rs
// Purpose:   HTTP client configuration
// Language:  Rust
//
// License:   FSL-1.1-ALv2
// Copyright: (c) 2026 HYPERI PTY LIMITED

//! HTTP client configuration with config cascade support.

use serde::{Deserialize, Serialize};

/// Configuration for the HTTP client.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpClientConfig {
    /// Request timeout in seconds. Default: 30.
    #[serde(default = "default_timeout_secs")]
    pub timeout_secs: u64,

    /// Connection timeout in seconds. Default: 10.
    #[serde(default = "default_connect_timeout_secs")]
    pub connect_timeout_secs: u64,

    /// Maximum number of retries for transient errors. Default: 3.
    #[serde(default = "default_max_retries")]
    pub max_retries: u32,

    /// Minimum retry interval in milliseconds. Default: 100.
    #[serde(default = "default_min_retry_interval_ms")]
    pub min_retry_interval_ms: u64,

    /// Maximum retry interval in milliseconds. Default: 30000 (30s).
    #[serde(default = "default_max_retry_interval_ms")]
    pub max_retry_interval_ms: u64,

    /// Custom User-Agent header. Default: None (uses reqwest default).
    #[serde(default)]
    pub user_agent: Option<String>,
}

fn default_timeout_secs() -> u64 {
    30
}
fn default_connect_timeout_secs() -> u64 {
    10
}
fn default_max_retries() -> u32 {
    3
}
fn default_min_retry_interval_ms() -> u64 {
    100
}
fn default_max_retry_interval_ms() -> u64 {
    30_000
}

impl Default for HttpClientConfig {
    fn default() -> Self {
        Self {
            timeout_secs: default_timeout_secs(),
            connect_timeout_secs: default_connect_timeout_secs(),
            max_retries: default_max_retries(),
            min_retry_interval_ms: default_min_retry_interval_ms(),
            max_retry_interval_ms: default_max_retry_interval_ms(),
            user_agent: None,
        }
    }
}

impl HttpClientConfig {
    /// Load from the config cascade under the `http_client` key.
    #[must_use]
    pub fn from_cascade() -> Self {
        #[cfg(feature = "config")]
        {
            if let Some(cfg) = crate::config::try_get()
                && let Ok(hc) = cfg.unmarshal_key_registered::<Self>("http_client")
            {
                return hc;
            }
        }
        Self::default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn defaults_are_sensible() {
        let config = HttpClientConfig::default();
        assert_eq!(config.timeout_secs, 30);
        assert_eq!(config.connect_timeout_secs, 10);
        assert_eq!(config.max_retries, 3);
        assert_eq!(config.min_retry_interval_ms, 100);
        assert_eq!(config.max_retry_interval_ms, 30_000);
        assert!(config.user_agent.is_none());
    }

    #[test]
    fn deserialise_from_yaml() {
        let yaml = r#"
timeout_secs: 60
max_retries: 5
user_agent: "my-app/1.0"
"#;
        let config: HttpClientConfig = serde_yaml_ng::from_str(yaml).unwrap();
        assert_eq!(config.timeout_secs, 60);
        assert_eq!(config.max_retries, 5);
        assert_eq!(config.user_agent.as_deref(), Some("my-app/1.0"));
        // Defaults for unset fields
        assert_eq!(config.connect_timeout_secs, 10);
    }
}