fix: Apply correct rate limiting behavior/precedence

sentry/src/transports/curl.rs

@@ -107,12 +107,13 @@ impl CurlHttpTransport {
             }
 
             match handle.response_code() {
-                Ok(_) => {
-                    if let Some(retry_after) = retry_after {
-                        rl.update_from_retry_after(&retry_after);
-                    }
+                Ok(response_code) => {
                     if let Some(sentry_header) = sentry_header {
                         rl.update_from_sentry_header(&sentry_header);
+                    } else if let Some(retry_after) = retry_after {
+                        rl.update_from_retry_after(&retry_after);
+                    } else if response_code == 429 {
+                        rl.update_from_429();
                     }
                 }
                 Err(err) => {

sentry/src/transports/ratelimit.rs

@@ -23,16 +23,14 @@ impl RateLimiter {
     /// Updates the RateLimiter with information from a `Retry-After` header.
     pub fn update_from_retry_after(&mut self, header: &str) {
         let new_time = if let Ok(value) = header.parse::<f64>() {
-            Some(SystemTime::now() + Duration::from_secs(value.ceil() as u64))
+            SystemTime::now() + Duration::from_secs(value.ceil() as u64)
         } else if let Ok(value) = parse_http_date(header) {
-            Some(value)
+            value
         } else {
-            None
+            SystemTime::now() + Duration::from_secs(60)
         };
 
-        if new_time.is_some() {
-            self.global = new_time;
-        }
+        self.global = Some(new_time);
     }
 
     /// Updates the RateLimiter with information from a `X-Sentry-Rate-Limits` header.
@@ -69,6 +67,11 @@ impl RateLimiter {
         }
     }
 
+    /// Updates the RateLimiter in response to a `429` status code.
+    pub fn update_from_429(&mut self) {
+        self.global = Some(SystemTime::now() + Duration::from_secs(60));
+    }
+
     /// Query the RateLimiter if a certain category of event is currently rate limited.
     ///
     /// If the given category is rate limited, it will return the remaining

sentry/src/transports/reqwest.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use reqwest_::{header as ReqwestHeaders, Client as ReqwestClient, Proxy};
+use reqwest_::{header as ReqwestHeaders, Client as ReqwestClient, Proxy, StatusCode};
 
 use super::thread::TransportThread;
 
@@ -56,18 +56,21 @@ impl ReqwestHttpTransport {
                 match request.send().await {
                     Ok(response) => {
                         let headers = response.headers();
-                        if let Some(retry_after) = headers
-                            .get(ReqwestHeaders::RETRY_AFTER)
-                            .and_then(|x| x.to_str().ok())
-                        {
-                            rl.update_from_retry_after(retry_after);
-                        }
+
                         if let Some(sentry_header) = headers
                             .get("x-sentry-rate-limits")
                             .and_then(|x| x.to_str().ok())
                         {
                             rl.update_from_sentry_header(sentry_header);
+                        } else if let Some(retry_after) = headers
+                            .get(ReqwestHeaders::RETRY_AFTER)
+                            .and_then(|x| x.to_str().ok())
+                        {
+                            rl.update_from_retry_after(retry_after);
+                        } else if response.status() == StatusCode::TOO_MANY_REQUESTS {
+                            rl.update_from_429();
                         }
+
                         match response.text().await {
                             Err(err) => {
                                 sentry_debug!("Failed to read sentry response: {}", err);

sentry/src/transports/surf.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use surf_::{http::headers as SurfHeaders, Client as SurfClient};
+use surf_::{http::headers as SurfHeaders, Client as SurfClient, StatusCode};
 
 use super::thread::TransportThread;
 
@@ -42,16 +42,17 @@ impl SurfHttpTransport {
             async move {
                 match request.await {
                     Ok(mut response) => {
-                        if let Some(retry_after) = response
-                            .header(SurfHeaders::RETRY_AFTER)
-                            .map(|x| x.as_str())
-                        {
-                            rl.update_from_retry_after(retry_after);
-                        }
                         if let Some(sentry_header) =
                             response.header("x-sentry-rate-limits").map(|x| x.as_str())
                         {
                             rl.update_from_retry_after(sentry_header);
+                        } else if let Some(retry_after) = response
+                            .header(SurfHeaders::RETRY_AFTER)
+                            .map(|x| x.as_str())
+                        {
+                            rl.update_from_retry_after(retry_after);
+                        } else if response.status() == StatusCode::TooManyRequests {
+                            rl.update_from_429();
                         }
 
                         match response.body_string().await {