Skip to main content

rate_limit_guard/
lib.rs

1use std::collections::HashMap;
2use std::path::PathBuf;
3use std::time::SystemTime;
4
5#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
6pub struct RateLimitState {
7    pub reset_at: f64,
8    pub recorded_at: f64,
9    pub reset_seconds: f64,
10}
11
12#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
13pub struct BucketState {
14    pub limit: Option<i64>,
15    pub remaining: Option<i64>,
16    pub reset_seconds: Option<f64>,
17    pub remaining_seconds_now: Option<f64>,
18}
19
20#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
21pub struct RateLimitTrackerState {
22    pub requests_min: Option<BucketState>,
23    pub requests_hour: Option<BucketState>,
24    pub tokens_min: Option<BucketState>,
25    pub tokens_hour: Option<BucketState>,
26}
27
28pub struct RateLimitGuard {
29    pub state_file_path: PathBuf,
30}
31
32fn get_now_secs() -> f64 {
33    SystemTime::now()
34        .duration_since(SystemTime::UNIX_EPOCH)
35        .map(|d| d.as_secs_f64())
36        .unwrap_or(0.0)
37}
38
39impl RateLimitGuard {
40    pub const MIN_RESET_FOR_BREAKER_SECONDS: f64 = 60.0;
41
42    pub fn new(state_file_path: Option<PathBuf>) -> Self {
43        let path = state_file_path.unwrap_or_else(|| {
44            let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
45            let mut p = PathBuf::from(home);
46            p.push(".rate_limits");
47            p.push("default.json");
48            p
49        });
50        Self { state_file_path: path }
51    }
52
53    pub fn get_remaining_cooldown(&self) -> Option<f64> {
54        if !self.state_file_path.exists() {
55            return None;
56        }
57        let raw = std::fs::read_to_string(&self.state_file_path).ok()?;
58        let state: RateLimitState = serde_json::from_str(&raw).ok()?;
59        let now = get_now_secs();
60        let remaining = state.reset_at - now;
61        if remaining > 0.0 {
62            return Some(remaining);
63        }
64        let _ = std::fs::remove_file(&self.state_file_path);
65        None
66    }
67
68    pub fn record_limit(
69        &self,
70        headers: Option<&HashMap<String, String>>,
71        error_context: Option<&serde_json::Value>,
72        default_cooldown_seconds: Option<f64>,
73    ) {
74        let now = get_now_secs();
75        let mut reset_at = None;
76
77        if let Some(header_sec) = self.parse_reset_seconds(headers) {
78            reset_at = Some(now + header_sec);
79        }
80
81        if reset_at.is_none() {
82            if let Some(ctx) = error_context {
83                if let Some(ctx_reset) = ctx.get("reset_at").and_then(|v| v.as_f64()) {
84                    if ctx_reset > now {
85                        reset_at = Some(ctx_reset);
86                    }
87                }
88            }
89        }
90
91        let reset_at_val = reset_at.unwrap_or_else(|| {
92            now + default_cooldown_seconds.unwrap_or(300.0)
93        });
94
95        let state = RateLimitState {
96            reset_at: reset_at_val,
97            recorded_at: now,
98            reset_seconds: reset_at_val - now,
99        };
100
101        if let Some(parent) = self.state_file_path.parent() {
102            let _ = std::fs::create_dir_all(parent);
103        }
104
105        let random_suffix: String = SystemTime::now()
106            .duration_since(SystemTime::UNIX_EPOCH)
107            .map(|d| d.as_nanos())
108            .unwrap_or(0)
109            .to_string();
110        let tmp_path = self.state_file_path.with_extension(format!("tmp{}", random_suffix));
111
112        if let Ok(serialized) = serde_json::to_string(&state) {
113            if std::fs::write(&tmp_path, serialized).is_ok() {
114                let _ = std::fs::rename(&tmp_path, &self.state_file_path);
115            }
116        }
117    }
118
119    pub fn clear(&self) {
120        if self.state_file_path.exists() {
121            let _ = std::fs::remove_file(&self.state_file_path);
122        }
123    }
124
125    pub fn is_genuine_limit(
126        &self,
127        headers: Option<&HashMap<String, String>>,
128        last_known_state: Option<&RateLimitTrackerState>,
129    ) -> bool {
130        let buckets = self.parse_buckets_from_headers(headers);
131        if self.has_exhausted_bucket(&buckets) {
132            return true;
133        }
134        if let Some(state) = last_known_state {
135            if self.has_exhausted_bucket_in_state(state) {
136                return true;
137            }
138        }
139        false
140    }
141
142    fn parse_reset_seconds(&self, headers: Option<&HashMap<String, String>>) -> Option<f64> {
143        let hdrs = headers?;
144        let keys = [
145            "x-ratelimit-reset-requests-1h",
146            "x-ratelimit-reset-requests",
147            "retry-after",
148        ];
149        for key in &keys {
150            for (k, v) in hdrs {
151                if k.to_ascii_lowercase() == *key {
152                    if let Ok(parsed) = v.parse::<f64>() {
153                        if parsed > 0.0 {
154                            return Some(parsed);
155                        }
156                    }
157                }
158            }
159        }
160        None
161    }
162
163    fn parse_buckets_from_headers(
164        &self,
165        headers: Option<&HashMap<String, String>>,
166    ) -> HashMap<String, (Option<i64>, Option<f64>)> {
167        let mut result = HashMap::new();
168        let hdrs = match headers {
169            None => return result,
170            Some(h) => h,
171        };
172
173        let tags = ["requests", "requests-1h", "tokens", "tokens-1h"];
174        for tag in &tags {
175            let rem_key = format!("x-ratelimit-remaining-{}", tag);
176            let res_key = format!("x-ratelimit-reset-{}", tag);
177
178            let mut remaining = None;
179            let mut reset = None;
180
181            for (k, v) in hdrs {
182                let k_lower = k.to_ascii_lowercase();
183                if k_lower == rem_key {
184                    remaining = v.parse::<i64>().ok();
185                } else if k_lower == res_key {
186                    reset = v.parse::<f64>().ok();
187                }
188            }
189
190            if remaining.is_some() || reset.is_some() {
191                result.insert(tag.to_string(), (remaining, reset));
192            }
193        }
194        result
195    }
196
197    fn has_exhausted_bucket(&self, buckets: &HashMap<String, (Option<i64>, Option<f64>)>) -> bool {
198        for (remaining, reset) in buckets.values() {
199            if let Some(rem) = remaining {
200                if *rem > 0 {
201                    continue;
202                }
203            }
204            if let Some(res) = reset {
205                if *res >= Self::MIN_RESET_FOR_BREAKER_SECONDS {
206                    return true;
207                }
208            }
209        }
210        false
211    }
212
213    fn has_exhausted_bucket_in_state(&self, state: &RateLimitTrackerState) -> bool {
214        let buckets = [
215            &state.requests_min,
216            &state.requests_hour,
217            &state.tokens_min,
218            &state.tokens_hour,
219        ];
220        for bucket in buckets.iter().copied().flatten() {
221            let limit = bucket.limit.unwrap_or(0);
222            let remaining = bucket.remaining.unwrap_or(0);
223            let reset = bucket.remaining_seconds_now
224                .or(bucket.reset_seconds)
225                .unwrap_or(0.0);
226
227            if limit <= 0 {
228                continue;
229            }
230            if remaining > 0 {
231                continue;
232            }
233            if reset >= Self::MIN_RESET_FOR_BREAKER_SECONDS {
234                return true;
235            }
236        }
237        false
238    }
239}
240
241pub fn format_remaining(seconds: f64) -> String {
242    let s = seconds.max(0.0).floor() as u64;
243    if s < 60 {
244        format!("{}s", s)
245    } else if s < 3600 {
246        let m = s / 60;
247        let sec = s % 60;
248        if sec > 0 {
249            format!("{}m {}s", m, sec)
250        } else {
251            format!("{}m", m)
252        }
253    } else {
254        let h = s / 3600;
255        let remainder = s % 3600;
256        let m = remainder / 60;
257        if m > 0 {
258            format!("{}h {}m", h, m)
259        } else {
260            format!("{}h", h)
261        }
262    }
263}