refactor: comment backoff delays remove stale todos and set initial retry params

Author: MarcosNicolau

aggregation_mode/Cargo.lock

@@ -6,8 +6,7 @@ edition = "2021"
 [dependencies]
 serde =  { workspace = true }
 tokio = { version = "1"}
-sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "migrate" ] }
-backon = "1.2.0"
+sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "migrate" , "uuid", "bigdecimal"] }
 tracing = { version = "0.1", features = ["log"] }
 
 [[bin]]

aggregation_mode/db/Cargo.toml

@@ -18,7 +18,6 @@ enum Operation {
 }
 
 /// A single DB node: connection pool plus shared health flags (used to prioritize nodes).
-
 #[derive(Debug)]
 struct DbNode {
     pool: Pool<Postgres>,
@@ -128,16 +127,41 @@ impl DbOrchestartor {
 
                     tracing::warn!(attempt = attempts, delay_milis = delay.as_millis(), error = ?err, "retrying after backoff");
                     tokio::time::sleep(delay).await;
-                    delay = self.backoff_delay(delay);
+                    delay = self.next_backoff_delay(delay);
                     attempts += 1;
                 }
             }
         }
     }
 
-    fn backoff_delay(&self, current: Duration) -> Duration {
-        let max = Duration::from_secs(self.retry_config.max_delay_seconds);
-        let scaled_secs = current.as_secs_f64() * f64::from(self.retry_config.factor);
+    // Exponential backoff with a hard cap.
+    //
+    // Each retry multiplies the previous delay by `retry_config.factor`,
+    // then clamps it to `max_delay_seconds`. This yields:
+    //
+    //   d_{n+1} = min(max, d_n * factor) => d_n = min(max, d_initial * factor^n)
+    //
+    // Example starting at 500ms with factor = 2.0 (no jitter):
+    //   retry 0: 0.5s
+    //   retry 1: 1.0s
+    //   retry 2: 2.0s
+    //   retry 3: 4.0s
+    //   retry 4: 8.0s
+    //   ...
+    // until the delay reaches `max_delay_seconds`, after which it stays at that max.
+    // see reference: https://en.wikipedia.org/wiki/Exponential_backoff
+    fn next_backoff_delay(&self, current_delay: Duration) -> Duration {
+        let max: Duration = Duration::from_secs(self.retry_config.max_delay_seconds);
+        // Defensive: factor should be >= 1.0 for backoff, we clamp it to avoid shrinking/NaN.
+        let factor = f64::from(self.retry_config.factor).max(1.0);
+
+        let scaled_secs = current_delay.as_secs_f64() * factor;
+        let scaled_secs = if scaled_secs.is_finite() {
+            scaled_secs
+        } else {
+            max.as_secs_f64()
+        };
+
         let scaled = Duration::from_secs_f64(scaled_secs);
         if scaled > max {
             max

aggregation_mode/db/src/orchestrator.rs

@@ -1,7 +1,16 @@
+use crate::types::Receipt;
 use db::{orchestrator::DbOrchestartor, retry::RetryConfig};
 use sqlx::types::{BigDecimal, Uuid};
 
-use crate::types::Receipt;
+// Retry parameters for Db queries
+/// Initial delay before first retry attempt (in milliseconds)
+const RETRY_MIN_DELAY_MILLIS: u64 = 500;
+/// Exponential backoff multiplier for retry delays
+const RETRY_FACTOR: f32 = 2.0;
+/// Maximum number of retry attempts
+const RETRY_MAX_TIMES: usize = 4;
+/// Maximum delay between retry attempts (in seconds)
+const RETRY_MAX_DELAY_SECONDS: u64 = 10;
 
 #[derive(Clone, Debug)]
 pub struct Db {
@@ -18,10 +27,10 @@ impl Db {
         let orchestrator = DbOrchestartor::try_new(
             connection_urls,
             RetryConfig {
-                factor: 0.0,
-                max_delay_seconds: 0,
-                max_times: 0,
-                min_delay_millis: 0,
+                min_delay_millis: RETRY_MIN_DELAY_MILLIS,
+                factor: RETRY_FACTOR,
+                max_times: RETRY_MAX_TIMES,
+                max_delay_seconds: RETRY_MAX_DELAY_SECONDS,
             },
         )
         .map_err(|e| DbError::ConnectError(e.to_string()))?;

aggregation_mode/gateway/src/db.rs

@@ -84,7 +84,6 @@ impl GatewayServer {
                 .json(AppResponse::new_unsucessfull("Internal server error", 500));
         };
 
-        // TODO: how to fix the mutable thing
         let state = state.get_ref();
         match state.db.count_tasks_by_address(&address).await {
             Ok(count) => HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!(

aggregation_mode/gateway/src/http.rs

@@ -1,6 +1,16 @@
 use db::{orchestrator::DbOrchestartor, retry::RetryConfig};
 use sqlx::types::BigDecimal;
 
+// Retry parameters for Db queries
+/// Initial delay before first retry attempt (in milliseconds)
+const RETRY_MIN_DELAY_MILLIS: u64 = 500;
+/// Exponential backoff multiplier for retry delays
+const RETRY_FACTOR: f32 = 2.0;
+/// Maximum number of retry attempts
+const RETRY_MAX_TIMES: usize = 5;
+/// Maximum delay between retry attempts (in seconds)
+const RETRY_MAX_DELAY_SECONDS: u64 = 30;
+
 #[derive(Clone, Debug)]
 pub struct Db {
     orchestartor: DbOrchestartor,
@@ -16,10 +26,10 @@ impl Db {
         let orchestartor = DbOrchestartor::try_new(
             connection_urls,
             RetryConfig {
-                factor: 0.0,
-                max_delay_seconds: 0,
-                max_times: 0,
-                min_delay_millis: 0,
+                min_delay_millis: RETRY_MIN_DELAY_MILLIS,
+                factor: RETRY_FACTOR,
+                max_times: RETRY_MAX_TIMES,
+                max_delay_seconds: RETRY_MAX_DELAY_SECONDS,
             },
         )
         .map_err(|e| DbError::ConnectError(e.to_string()))?;